_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer6VarRefEEEPT_PS1_:
  551|  73.2k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  73.2k|    static_assert(
  553|  73.2k|        InternalHelper<T>::is_arena_constructable::value,
  554|  73.2k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  73.2k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 73.2k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  73.2k|      return InternalHelper<T>::New();
  559|  73.2k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  73.2k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer6VarRefEE3NewEv:
  487|  73.2k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  73.2k|      return new T(nullptr);
  489|  73.2k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer7ArrTypeEEEPT_PS1_:
  551|  58.5k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  58.5k|    static_assert(
  553|  58.5k|        InternalHelper<T>::is_arena_constructable::value,
  554|  58.5k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  58.5k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 58.5k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  58.5k|      return InternalHelper<T>::New();
  559|  58.5k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  58.5k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer7ArrTypeEE3NewEv:
  487|  58.5k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  58.5k|      return new T(nullptr);
  489|  58.5k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer6KVPairEEEPT_PS1_:
  551|   129k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   129k|    static_assert(
  553|   129k|        InternalHelper<T>::is_arena_constructable::value,
  554|   129k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   129k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 129k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   129k|      return InternalHelper<T>::New();
  559|   129k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   129k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer6KVPairEE3NewEv:
  487|   129k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   129k|      return new T(nullptr);
  489|   129k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer8HashTypeEEEPT_PS1_:
  551|  20.6k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  20.6k|    static_assert(
  553|  20.6k|        InternalHelper<T>::is_arena_constructable::value,
  554|  20.6k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  20.6k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 20.6k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  20.6k|      return InternalHelper<T>::New();
  559|  20.6k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  20.6k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer8HashTypeEE3NewEv:
  487|  20.6k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  20.6k|      return new T(nullptr);
  489|  20.6k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer9MathConstEEEPT_PS1_:
  551|  3.09k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  3.09k|    static_assert(
  553|  3.09k|        InternalHelper<T>::is_arena_constructable::value,
  554|  3.09k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  3.09k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 3.09k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  3.09k|      return InternalHelper<T>::New();
  559|  3.09k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  3.09k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer9MathConstEE3NewEv:
  487|  3.09k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  3.09k|      return new T(nullptr);
  489|  3.09k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer5ConstEEEPT_PS1_:
  551|   291k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   291k|    static_assert(
  553|   291k|        InternalHelper<T>::is_arena_constructable::value,
  554|   291k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   291k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 291k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   291k|      return InternalHelper<T>::New();
  559|   291k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   291k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer5ConstEE3NewEv:
  487|   291k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   291k|      return new T(nullptr);
  489|   291k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer8BinaryOpEEEPT_PS1_:
  551|   131k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   131k|    static_assert(
  553|   131k|        InternalHelper<T>::is_arena_constructable::value,
  554|   131k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   131k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 131k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   131k|      return InternalHelper<T>::New();
  559|   131k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   131k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer8BinaryOpEE3NewEv:
  487|   131k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   131k|      return new T(nullptr);
  489|   131k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer6RvalueEEEPT_PS1_:
  551|   580k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   580k|    static_assert(
  553|   580k|        InternalHelper<T>::is_arena_constructable::value,
  554|   580k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   580k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 580k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   580k|      return InternalHelper<T>::New();
  559|   580k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   580k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer6RvalueEE3NewEv:
  487|   580k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   580k|      return new T(nullptr);
  489|   580k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer19AssignmentStatementEEEPT_PS1_:
  551|   215k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   215k|    static_assert(
  553|   215k|        InternalHelper<T>::is_arena_constructable::value,
  554|   215k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   215k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 215k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   215k|      return InternalHelper<T>::New();
  559|   215k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   215k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer19AssignmentStatementEE3NewEv:
  487|   215k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   215k|      return new T(nullptr);
  489|   215k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer6IfElseEEEPT_PS1_:
  551|  17.5k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  17.5k|    static_assert(
  553|  17.5k|        InternalHelper<T>::is_arena_constructable::value,
  554|  17.5k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  17.5k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 17.5k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  17.5k|      return InternalHelper<T>::New();
  559|  17.5k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  17.5k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer6IfElseEE3NewEv:
  487|  17.5k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  17.5k|      return new T(nullptr);
  489|  17.5k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer7TernaryEEEPT_PS1_:
  551|  8.65k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  8.65k|    static_assert(
  553|  8.65k|        InternalHelper<T>::is_arena_constructable::value,
  554|  8.65k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  8.65k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 8.65k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  8.65k|      return InternalHelper<T>::New();
  559|  8.65k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  8.65k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer7TernaryEE3NewEv:
  487|  8.65k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  8.65k|      return new T(nullptr);
  489|  8.65k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer11ObjectSpaceEEEPT_PS1_:
  551|  20.6k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  20.6k|    static_assert(
  553|  20.6k|        InternalHelper<T>::is_arena_constructable::value,
  554|  20.6k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  20.6k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 20.6k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  20.6k|      return InternalHelper<T>::New();
  559|  20.6k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  20.6k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer11ObjectSpaceEE3NewEv:
  487|  20.6k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  20.6k|      return new T(nullptr);
  489|  20.6k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer4TimeEEEPT_PS1_:
  551|  10.2k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  10.2k|    static_assert(
  553|  10.2k|        InternalHelper<T>::is_arena_constructable::value,
  554|  10.2k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  10.2k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 10.2k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  10.2k|      return InternalHelper<T>::New();
  559|  10.2k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  10.2k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer4TimeEE3NewEv:
  487|  10.2k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  10.2k|      return new T(nullptr);
  489|  10.2k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer5ArrayEEEPT_PS1_:
  551|  56.1k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  56.1k|    static_assert(
  553|  56.1k|        InternalHelper<T>::is_arena_constructable::value,
  554|  56.1k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  56.1k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 56.1k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  56.1k|      return InternalHelper<T>::New();
  559|  56.1k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  56.1k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer5ArrayEE3NewEv:
  487|  56.1k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  56.1k|      return new T(nullptr);
  489|  56.1k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer8MathTypeEEEPT_PS1_:
  551|  9.45k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  9.45k|    static_assert(
  553|  9.45k|        InternalHelper<T>::is_arena_constructable::value,
  554|  9.45k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  9.45k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 9.45k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  9.45k|      return InternalHelper<T>::New();
  559|  9.45k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  9.45k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer8MathTypeEE3NewEv:
  487|  9.45k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  9.45k|      return new T(nullptr);
  489|  9.45k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer7MathOpsEEEPT_PS1_:
  551|  9.47k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  9.47k|    static_assert(
  553|  9.47k|        InternalHelper<T>::is_arena_constructable::value,
  554|  9.47k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  9.47k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 9.47k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  9.47k|      return InternalHelper<T>::New();
  559|  9.47k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  9.47k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer7MathOpsEE3NewEv:
  487|  9.47k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  9.47k|      return new T(nullptr);
  489|  9.47k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer12BuiltinFuncsEEEPT_PS1_:
  551|   119k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   119k|    static_assert(
  553|   119k|        InternalHelper<T>::is_arena_constructable::value,
  554|   119k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   119k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 119k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   119k|      return InternalHelper<T>::New();
  559|   119k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   119k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer12BuiltinFuncsEE3NewEv:
  487|   119k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   119k|      return new T(nullptr);
  489|   119k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer9StatementEEEPT_PS1_:
  551|   554k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|   554k|    static_assert(
  553|   554k|        InternalHelper<T>::is_arena_constructable::value,
  554|   554k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|   554k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 554k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|   554k|      return InternalHelper<T>::New();
  559|   554k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|   554k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer9StatementEE3NewEv:
  487|   554k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|   554k|      return new T(nullptr);
  489|   554k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN11ruby_fuzzer12StatementSeqEEEPT_PS1_:
  551|  70.0k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  552|  70.0k|    static_assert(
  553|  70.0k|        InternalHelper<T>::is_arena_constructable::value,
  554|  70.0k|        "CreateMessage can only construct types that are ArenaConstructable");
  555|  70.0k|    if (arena == nullptr) {
  ------------------
  |  Branch (555:9): [True: 70.0k, False: 0]
  ------------------
  556|       |      // Generated arena constructor T(Arena*) is protected. Call via
  557|       |      // InternalHelper.
  558|  70.0k|      return InternalHelper<T>::New();
  559|  70.0k|    } else {
  560|      0|      return arena->DoCreateMessage<T>();
  561|      0|    }
  562|  70.0k|  }
_ZN6google8protobuf5Arena14InternalHelperIN11ruby_fuzzer12StatementSeqEE3NewEv:
  487|  70.0k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  488|  70.0k|      return new T(nullptr);
  489|  70.0k|    }

_ZN6google8protobuf8internal15TaggedStringPtrC2EPNS1_21ExplicitlyConstructedINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELm8EEE:
  133|   258k|      : ptr_(ptr) {}
_ZNK6google8protobuf8internal15TaggedStringPtr3GetEv:
  189|   258k|  inline std::string* Get() const {
  190|   258k|    return reinterpret_cast<std::string*>(as_int() & ~kMask);
  191|   258k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr6as_intEv:
  210|   258k|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  299|   258k|  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
  300|       |    // Unconditionally mask away the tag.
  301|   258k|    return *tagged_ptr_.Get();
  302|   258k|  }
_ZN6google8protobuf8internal14ArenaStringPtr11InitDefaultEv:
  395|   258k|inline void ArenaStringPtr::InitDefault() {
  396|   258k|  tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
  397|   258k|}

_ZN6google8protobuf8internal10CachedSizeC2Ev:
  198|  2.38M|  constexpr CachedSize() noexcept : atom_(Scalar{}) {}

_ZN6google8protobuf8internal7HasBitsILm1EEixEi:
   57|  3.53k|  PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) {
   58|  3.53k|    return has_bits_[index];
   59|  3.53k|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   51|   676k|  PROTOBUF_NDEBUG_INLINE constexpr HasBits() : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm1EE5ClearEv:
   53|  3.53k|  PROTOBUF_NDEBUG_INLINE void Clear() {
   54|  3.53k|    memset(has_bits_, 0, sizeof(has_bits_));
   55|  3.53k|  }

_ZN6google8protobuf7MessageC2EPNS0_5ArenaE:
  414|  2.38M|  inline explicit Message(Arena* arena) : MessageLite(arena) {}

_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  468|  2.38M|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv:
  479|   738k|  Arena* GetArenaForAllocation() const { return _internal_metadata_.arena(); }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer6VarRefEEEPT_PNS0_5ArenaE:
  464|  73.2k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  73.2k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  73.2k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer7ArrTypeEEEPT_PNS0_5ArenaE:
  464|  58.5k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  58.5k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  58.5k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer6KVPairEEEPT_PNS0_5ArenaE:
  464|   129k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   129k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   129k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer8HashTypeEEEPT_PNS0_5ArenaE:
  464|  20.6k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  20.6k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  20.6k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer9MathConstEEEPT_PNS0_5ArenaE:
  464|  3.09k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  3.09k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  3.09k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer5ConstEEEPT_PNS0_5ArenaE:
  464|   291k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   291k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   291k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer8BinaryOpEEEPT_PNS0_5ArenaE:
  464|   131k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   131k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   131k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer6RvalueEEEPT_PNS0_5ArenaE:
  464|   580k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   580k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   580k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer19AssignmentStatementEEEPT_PNS0_5ArenaE:
  464|   215k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   215k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   215k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer6IfElseEEEPT_PNS0_5ArenaE:
  464|  17.5k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  17.5k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  17.5k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer7TernaryEEEPT_PNS0_5ArenaE:
  464|  8.65k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  8.65k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  8.65k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer11ObjectSpaceEEEPT_PNS0_5ArenaE:
  464|  20.6k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  20.6k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  20.6k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer4TimeEEEPT_PNS0_5ArenaE:
  464|  10.2k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  10.2k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  10.2k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer5ArrayEEEPT_PNS0_5ArenaE:
  464|  56.1k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  56.1k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  56.1k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer8MathTypeEEEPT_PNS0_5ArenaE:
  464|  9.45k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  9.45k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  9.45k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer7MathOpsEEEPT_PNS0_5ArenaE:
  464|  9.47k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  9.47k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  9.47k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer12BuiltinFuncsEEEPT_PNS0_5ArenaE:
  464|   119k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   119k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   119k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer9StatementEEEPT_PNS0_5ArenaE:
  464|   554k|  static T* CreateMaybeMessage(Arena* arena) {
  465|   554k|    return Arena::CreateMaybeMessage<T>(arena);
  466|   554k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN11ruby_fuzzer12StatementSeqEEEPT_PNS0_5ArenaE:
  464|  70.0k|  static T* CreateMaybeMessage(Arena* arena) {
  465|  70.0k|    return Arena::CreateMaybeMessage<T>(arena);
  466|  70.0k|  }
_ZN6google8protobuf11MessageLiteD2Ev:
  175|  2.38M|  virtual ~MessageLite() = default;

_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   70|  2.38M|  explicit InternalMetadata(Arena* arena) {
   71|  2.38M|    ptr_ = reinterpret_cast<intptr_t>(arena);
   72|  2.38M|  }
_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   98|   738k|  PROTOBUF_NDEBUG_INLINE Arena* arena() const {
   99|   738k|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  538|   738k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (538:36): [True: 0, False: 738k]
  |  |  |  Branch (538:54): [Folded - Ignored]
  |  |  |  Branch (538:63): [True: 0, False: 738k]
  |  |  ------------------
  ------------------
  100|      0|      return PtrValue<ContainerBase>()->arena;
  101|   738k|    } else {
  102|   738k|      return PtrValue<Arena>();
  103|   738k|    }
  104|   738k|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
  106|  3.14M|  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
  107|  3.14M|    return HasUnknownFieldsTag();
  108|  3.14M|  }
_ZNK6google8protobuf8internal16InternalMetadata19HasUnknownFieldsTagEv:
  173|  3.14M|  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
  174|  3.14M|    return ptr_ & kUnknownFieldsTagMask;
  175|  3.14M|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  178|  3.11M|  U* PtrValue() const {
  179|  3.11M|    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
  180|  3.11M|  }
_ZN6google8protobuf8internal16InternalMetadata9MergeFromINS0_15UnknownFieldSetEEEvRKS2_:
  151|  5.96k|  PROTOBUF_NDEBUG_INLINE void MergeFrom(const InternalMetadata& other) {
  152|  5.96k|    if (other.have_unknown_fields()) {
  ------------------
  |  Branch (152:9): [True: 0, False: 5.96k]
  ------------------
  153|      0|      DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
  154|      0|    }
  155|  5.96k|  }
_ZN6google8protobuf8internal16InternalMetadata17DeleteReturnArenaINS0_15UnknownFieldSetEEEPNS0_5ArenaEv:
   90|  2.38M|  Arena* DeleteReturnArena() {
   91|  2.38M|    if (have_unknown_fields()) {
  ------------------
  |  Branch (91:9): [True: 0, False: 2.38M]
  ------------------
   92|      0|      return DeleteOutOfLineHelper<T>();
   93|  2.38M|    } else {
   94|  2.38M|      return PtrValue<Arena>();
   95|  2.38M|    }
   96|  2.38M|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINS0_15UnknownFieldSetEEEvv:
  158|  18.7k|  PROTOBUF_NDEBUG_INLINE void Clear() {
  159|  18.7k|    if (have_unknown_fields()) {
  ------------------
  |  Branch (159:9): [True: 0, False: 18.7k]
  ------------------
  160|      0|      DoClear<T>();
  161|      0|    }
  162|  18.7k|  }

_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
  169|   149k|      : arena_(arena), current_size_(0), total_size_(0), rep_(nullptr) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  174|   149k|  ~RepeatedPtrFieldBase() {
  175|       |#ifndef NDEBUG
  176|       |    // Try to trigger segfault / asan failure in non-opt builds. If arena_
  177|       |    // lifetime has ended before the destructor.
  178|       |    if (arena_) (void)arena_->SpaceAllocated();
  179|       |#endif
  180|   149k|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
  183|   199k|  int size() const { return current_size_; }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase12NeedsDestroyEv:
  261|   149k|  bool NeedsDestroy() const { return rep_ != nullptr && arena_ == nullptr; }
  ------------------
  |  Branch (261:38): [True: 43.2k, False: 106k]
  |  Branch (261:57): [True: 43.2k, False: 0]
  ------------------
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
  372|  85.3k|  void* const* raw_data() const { return rep_ ? rep_->elements : nullptr; }
  ------------------
  |  Branch (372:42): [True: 85.3k, False: 0]
  ------------------
_ZN6google8protobuf8internal20RepeatedPtrFieldBase19ExchangeCurrentSizeEi:
  668|     16|  inline int ExchangeCurrentSize(int new_size) {
  669|     16|    int prev_size = current_size_;
  670|     16|    current_size_ = new_size;
  671|     16|    return prev_size;
  672|     16|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE4sizeEv:
 1329|  70.2k|inline int RepeatedPtrField<Element>::size() const {
 1330|  70.2k|  return RepeatedPtrFieldBase::size();
 1331|  70.2k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE5ClearEv:
 1484|  4.82k|inline void RepeatedPtrField<Element>::Clear() {
 1485|  4.82k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1486|  4.82k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE11TypeHandlerEEEvv:
  283|  4.82k|  void Clear() {
  284|  4.82k|    const int n = current_size_;
  285|  4.82k|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|  4.82k|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|  4.82k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  4.82k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  4.82k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  286|  4.82k|    if (n > 0) {
  ------------------
  |  Branch (286:9): [True: 0, False: 4.82k]
  ------------------
  287|      0|      ClearNonEmpty<TypeHandler>();
  288|      0|    }
  289|  4.82k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE4sizeEv:
 1329|  27.8k|inline int RepeatedPtrField<Element>::size() const {
 1330|  27.8k|  return RepeatedPtrFieldBase::size();
 1331|  27.8k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE5ClearEv:
 1484|     16|inline void RepeatedPtrField<Element>::Clear() {
 1485|     16|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1486|     16|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE11TypeHandlerEEEvv:
  283|     16|  void Clear() {
  284|     16|    const int n = current_size_;
  285|     16|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     16|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     16|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     16|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     16|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  286|     16|    if (n > 0) {
  ------------------
  |  Branch (286:9): [True: 0, False: 16]
  ------------------
  287|      0|      ClearNonEmpty<TypeHandler>();
  288|      0|    }
  289|     16|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE4sizeEv:
 1329|   101k|inline int RepeatedPtrField<Element>::size() const {
 1330|   101k|  return RepeatedPtrFieldBase::size();
 1331|   101k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE5ClearEv:
 1484|     24|inline void RepeatedPtrField<Element>::Clear() {
 1485|     24|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1486|     24|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE11TypeHandlerEEEvv:
  283|     24|  void Clear() {
  284|     24|    const int n = current_size_;
  285|     24|    ABSL_DCHECK_GE(n, 0);
  ------------------
  |  |   78|     24|  ABSL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   94|     24|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     24|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     24|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  286|     24|    if (n > 0) {
  ------------------
  |  Branch (286:9): [True: 16, False: 8]
  ------------------
  287|     16|      ClearNonEmpty<TypeHandler>();
  288|     16|    }
  289|     24|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase13ClearNonEmptyINS0_16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE11TypeHandlerEEEvv:
  696|     16|  PROTOBUF_NOINLINE void ClearNonEmpty() {
  697|     16|    const int n = current_size_;
  698|     16|    void* const* elements = rep_->elements;
  699|     16|    int i = 0;
  700|     16|    ABSL_DCHECK_GT(
  ------------------
  |  |   80|     16|  ABSL_DCHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   96|     16|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|     16|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|     16|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  701|     16|        n,
  702|     16|        0);  // do/while loop to avoid initial test because we know n > 0
  703|  3.27k|    do {
  704|  3.27k|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
  705|  3.27k|    } while (i < n);
  ------------------
  |  Branch (705:14): [True: 3.25k, False: 16]
  ------------------
  706|     16|    ExchangeCurrentSize(0);
  707|     16|  }
_ZN6google8protobuf8internal18GenericTypeHandlerIN11ruby_fuzzer9StatementEE5ClearEPS4_:
  819|  3.27k|  static inline void Clear(GenericType* value) { value->Clear(); }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE11TypeHandlerEEEPNT_4TypeEPv:
  685|  3.27k|  static inline typename TypeHandler::Type* cast(void* element) {
  686|  3.27k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  687|  3.27k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEEC2EPNS0_5ArenaE:
 1246|  58.5k|    : RepeatedPtrFieldBase(arena) {
 1247|  58.5k|  StaticValidityCheck();
 1248|  58.5k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE19StaticValidityCheckEv:
  913|   117k|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  914|   117k|    static_assert(
  915|   117k|        absl::disjunction<
  916|   117k|            internal::is_supported_string_type<Element>,
  917|   117k|            internal::is_supported_message_type<Element>>::value,
  918|   117k|        "We only support string and Message types in RepeatedPtrField.");
  919|   117k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEED2Ev:
 1266|  58.5k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1267|  58.5k|  StaticValidityCheck();
 1268|       |#ifdef __cpp_if_constexpr
 1269|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1270|       |#else
 1271|  58.5k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1271:7): [Folded - Ignored]
  ------------------
 1272|  58.5k|#endif
 1273|  58.5k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1273:9): [True: 7.61k, False: 50.9k]
  ------------------
 1274|  58.5k|  } else {
 1275|      0|    Destroy<TypeHandler>();
 1276|      0|  }
 1277|  58.5k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEEC2EPNS0_5ArenaE:
 1246|  20.6k|    : RepeatedPtrFieldBase(arena) {
 1247|  20.6k|  StaticValidityCheck();
 1248|  20.6k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE19StaticValidityCheckEv:
  913|  41.3k|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  914|  41.3k|    static_assert(
  915|  41.3k|        absl::disjunction<
  916|  41.3k|            internal::is_supported_string_type<Element>,
  917|  41.3k|            internal::is_supported_message_type<Element>>::value,
  918|  41.3k|        "We only support string and Message types in RepeatedPtrField.");
  919|  41.3k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEED2Ev:
 1266|  20.6k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1267|  20.6k|  StaticValidityCheck();
 1268|       |#ifdef __cpp_if_constexpr
 1269|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1270|       |#else
 1271|  20.6k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1271:7): [Folded - Ignored]
  ------------------
 1272|  20.6k|#endif
 1273|  20.6k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1273:9): [True: 3.61k, False: 17.0k]
  ------------------
 1274|  20.6k|  } else {
 1275|      0|    Destroy<TypeHandler>();
 1276|      0|  }
 1277|  20.6k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEEC2EPNS0_5ArenaE:
 1246|  70.0k|    : RepeatedPtrFieldBase(arena) {
 1247|  70.0k|  StaticValidityCheck();
 1248|  70.0k|}
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE19StaticValidityCheckEv:
  913|   140k|  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
  914|   140k|    static_assert(
  915|   140k|        absl::disjunction<
  916|   140k|            internal::is_supported_string_type<Element>,
  917|   140k|            internal::is_supported_message_type<Element>>::value,
  918|   140k|        "We only support string and Message types in RepeatedPtrField.");
  919|   140k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEED2Ev:
 1266|  70.0k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1267|  70.0k|  StaticValidityCheck();
 1268|       |#ifdef __cpp_if_constexpr
 1269|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1270|       |#else
 1271|  70.0k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1271:7): [Folded - Ignored]
  ------------------
 1272|  70.0k|#endif
 1273|  70.0k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1273:9): [True: 31.9k, False: 38.0k]
  ------------------
 1274|  70.0k|  } else {
 1275|      0|    Destroy<TypeHandler>();
 1276|      0|  }
 1277|  70.0k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE5beginEv:
 1845|  7.26k|RepeatedPtrField<Element>::begin() const {
 1846|  7.26k|  return iterator(raw_data());
 1847|  7.26k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN11ruby_fuzzer5ConstEEC2EPKPv:
 1643|  14.5k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer5ConstEEC2IS4_LPv0EEERKNS2_IT_EE:
 1651|  14.5k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE3endEv:
 1860|  7.26k|RepeatedPtrField<Element>::end() const {
 1861|  7.26k|  return iterator(raw_data() + size());
 1862|  7.26k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN11ruby_fuzzer5ConstEEES8_:
 1673|   253k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1674|   253k|    return x.it_ != y.it_;
 1675|   253k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer5ConstEEppEv:
 1658|   246k|  iterator& operator++() {
 1659|   246k|    ++it_;
 1660|   246k|    return *this;
 1661|   246k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer5ConstEEdeEv:
 1654|   246k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE9MergeFromERKS4_:
 1490|  2.41k|    const RepeatedPtrField& other) {
 1491|  2.41k|  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 1492|  2.41k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase9MergeFromINS0_16RepeatedPtrFieldIN11ruby_fuzzer5ConstEE11TypeHandlerEEEvRKS2_:
  292|  2.41k|  void MergeFrom(const RepeatedPtrFieldBase& other) {
  293|       |    // To avoid unnecessary code duplication and reduce binary size, we use a
  294|       |    // layered approach to implementing MergeFrom(). The toplevel method is
  295|       |    // templated, so we get a small thunk per concrete message type in the
  296|       |    // binary. This calls a shared implementation with most of the logic,
  297|       |    // passing a function pointer to another type-specific piece of code that
  298|       |    // calls the object-allocate and merge handlers.
  299|  2.41k|    ABSL_DCHECK_NE(&other, this);
  ------------------
  |  |   72|  2.41k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.41k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.41k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.41k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  300|  2.41k|    if (other.current_size_ == 0) return;
  ------------------
  |  Branch (300:9): [True: 2.41k, False: 0]
  ------------------
  301|      0|    MergeFromInternal(other,
  302|      0|                      &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
  303|      0|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE5beginEv:
 1845|  3.61k|RepeatedPtrField<Element>::begin() const {
 1846|  3.61k|  return iterator(raw_data());
 1847|  3.61k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN11ruby_fuzzer6KVPairEEC2EPKPv:
 1643|  7.22k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer6KVPairEEC2IS4_LPv0EEERKNS2_IT_EE:
 1651|  7.22k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE3endEv:
 1860|  3.61k|RepeatedPtrField<Element>::end() const {
 1861|  3.61k|  return iterator(raw_data() + size());
 1862|  3.61k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN11ruby_fuzzer6KVPairEEES8_:
 1673|   133k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1674|   133k|    return x.it_ != y.it_;
 1675|   133k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer6KVPairEEppEv:
 1658|   129k|  iterator& operator++() {
 1659|   129k|    ++it_;
 1660|   129k|    return *this;
 1661|   129k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer6KVPairEEdeEv:
 1654|   129k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE9MergeFromERKS4_:
 1490|      8|    const RepeatedPtrField& other) {
 1491|      8|  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 1492|      8|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase9MergeFromINS0_16RepeatedPtrFieldIN11ruby_fuzzer6KVPairEE11TypeHandlerEEEvRKS2_:
  292|      8|  void MergeFrom(const RepeatedPtrFieldBase& other) {
  293|       |    // To avoid unnecessary code duplication and reduce binary size, we use a
  294|       |    // layered approach to implementing MergeFrom(). The toplevel method is
  295|       |    // templated, so we get a small thunk per concrete message type in the
  296|       |    // binary. This calls a shared implementation with most of the logic,
  297|       |    // passing a function pointer to another type-specific piece of code that
  298|       |    // calls the object-allocate and merge handlers.
  299|      8|    ABSL_DCHECK_NE(&other, this);
  ------------------
  |  |   72|      8|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|      8|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      8|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      8|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  300|      8|    if (other.current_size_ == 0) return;
  ------------------
  |  Branch (300:9): [True: 8, False: 0]
  ------------------
  301|      0|    MergeFromInternal(other,
  302|      0|                      &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
  303|      0|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE5beginEv:
 1845|  31.8k|RepeatedPtrField<Element>::begin() const {
 1846|  31.8k|  return iterator(raw_data());
 1847|  31.8k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN11ruby_fuzzer9StatementEEC2EPKPv:
 1643|  63.6k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer9StatementEEC2IS4_LPv0EEERKNS2_IT_EE:
 1651|  63.6k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE3endEv:
 1860|  31.8k|RepeatedPtrField<Element>::end() const {
 1861|  31.8k|  return iterator(raw_data() + size());
 1862|  31.8k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN11ruby_fuzzer9StatementEEES8_:
 1673|   581k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1674|   581k|    return x.it_ != y.it_;
 1675|   581k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer9StatementEEppEv:
 1658|   549k|  iterator& operator++() {
 1659|   549k|    ++it_;
 1660|   549k|    return *this;
 1661|   549k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN11ruby_fuzzer9StatementEEdeEv:
 1654|   549k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE9MergeFromERKS4_:
 1490|      4|    const RepeatedPtrField& other) {
 1491|      4|  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 1492|      4|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase9MergeFromINS0_16RepeatedPtrFieldIN11ruby_fuzzer9StatementEE11TypeHandlerEEEvRKS2_:
  292|      4|  void MergeFrom(const RepeatedPtrFieldBase& other) {
  293|       |    // To avoid unnecessary code duplication and reduce binary size, we use a
  294|       |    // layered approach to implementing MergeFrom(). The toplevel method is
  295|       |    // templated, so we get a small thunk per concrete message type in the
  296|       |    // binary. This calls a shared implementation with most of the logic,
  297|       |    // passing a function pointer to another type-specific piece of code that
  298|       |    // calls the object-allocate and merge handlers.
  299|      4|    ABSL_DCHECK_NE(&other, this);
  ------------------
  |  |   72|      4|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|      4|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      4|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      4|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  300|      4|    if (other.current_size_ == 0) return;
  ------------------
  |  Branch (300:9): [True: 4, False: 0]
  ------------------
  301|      0|    MergeFromInternal(other,
  302|      0|                      &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
  303|      0|  }

mrb_init_mrbgems:
  162|  1.74k|mrb_init_mrbgems(mrb_state *mrb) {
  163|  1.74k|  int ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  1.74k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  164|  66.3k|  for (int i = 0; i < NUM_GEMS; i++) {
  ------------------
  |  |  135|  66.3k|#define NUM_GEMS ((int)(sizeof(gem_funcs) / sizeof(gem_funcs[0])))
  ------------------
  |  Branch (164:19): [True: 64.5k, False: 1.74k]
  ------------------
  165|  64.5k|    gem_funcs[i].init(mrb);
  166|  64.5k|    mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  64.5k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  167|  64.5k|    mrb_vm_ci_env_clear(mrb, mrb->c->cibase);
  168|  64.5k|    if (mrb->exc) {
  ------------------
  |  Branch (168:9): [True: 0, False: 64.5k]
  ------------------
  169|      0|      mrb_exc_raise(mrb, mrb_obj_value(mrb->exc));
  170|      0|    }
  171|  64.5k|  }
  172|  1.74k|  mrb_state_atexit(mrb, mrb_final_mrbgems);
  173|  1.74k|}
gem_init.c:mrb_final_mrbgems:
  153|  1.74k|mrb_final_mrbgems(mrb_state *mrb) {
  154|  1.74k|  struct final_mrbgems a = { NUM_GEMS - 1, mrb_gc_arena_save(mrb) };
  ------------------
  |  |  135|  1.74k|#define NUM_GEMS ((int)(sizeof(gem_funcs) / sizeof(gem_funcs[0])))
  ------------------
                struct final_mrbgems a = { NUM_GEMS - 1, mrb_gc_arena_save(mrb) };
  ------------------
  |  | 1306|  1.74k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  155|  3.49k|  for (; a.i >= 0; a.i--) {
  ------------------
  |  Branch (155:10): [True: 1.74k, False: 1.74k]
  ------------------
  156|  1.74k|    mrb_protect_error(mrb, final_mrbgems_body, &a, NULL);
  157|  1.74k|    mrb_gc_arena_restore(mrb, a.ai);
  ------------------
  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  158|  1.74k|  }
  159|  1.74k|}
gem_init.c:final_mrbgems_body:
  143|  1.74k|final_mrbgems_body(mrb_state *mrb, void *ud) {
  144|  1.74k|  struct final_mrbgems *p = (struct final_mrbgems*)ud;
  145|  66.3k|  for (; p->i >= 0; p->i--) {
  ------------------
  |  Branch (145:10): [True: 64.5k, False: 1.74k]
  ------------------
  146|  64.5k|    gem_funcs[p->i].final(mrb);
  147|  64.5k|    mrb_gc_arena_restore(mrb, p->ai);
  ------------------
  |  | 1307|  64.5k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  148|  64.5k|  }
  149|  1.74k|  return mrb_nil_value();
  150|  1.74k|}

GENERATED_TMP_mrb_mruby_array_ext_gem_init:
  902|  1.74k|void GENERATED_TMP_mrb_mruby_array_ext_gem_init(mrb_state *mrb) {
  903|  1.74k|  gem_mrblib_mruby_array_ext_proc_init_syms(mrb);
  904|  1.74k|  mrb_mruby_array_ext_gem_init(mrb);
  905|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_array_ext_proc);
  906|  1.74k|}
GENERATED_TMP_mrb_mruby_array_ext_gem_final:
  908|  1.74k|void GENERATED_TMP_mrb_mruby_array_ext_gem_final(mrb_state *mrb) {
  909|  1.74k|  mrb_mruby_array_ext_gem_final(mrb);
  910|  1.74k|}
gem_init.c:gem_mrblib_mruby_array_ext_proc_init_syms:
  897|  1.74k|{
  898|  1.74k|}

GENERATED_TMP_mrb_mruby_binding_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_binding_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_binding_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_binding_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_binding_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_binding_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_class_ext_gem_init:
  142|  1.74k|void GENERATED_TMP_mrb_mruby_class_ext_gem_init(mrb_state *mrb) {
  143|  1.74k|  gem_mrblib_mruby_class_ext_proc_init_syms(mrb);
  144|  1.74k|  mrb_mruby_class_ext_gem_init(mrb);
  145|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_class_ext_proc);
  146|  1.74k|}
GENERATED_TMP_mrb_mruby_class_ext_gem_final:
  148|  1.74k|void GENERATED_TMP_mrb_mruby_class_ext_gem_final(mrb_state *mrb) {
  149|  1.74k|  mrb_mruby_class_ext_gem_final(mrb);
  150|  1.74k|}
gem_init.c:gem_mrblib_mruby_class_ext_proc_init_syms:
  137|  1.74k|{
  138|  1.74k|}

GENERATED_TMP_mrb_mruby_cmath_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_cmath_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_cmath_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_cmath_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_cmath_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_cmath_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_compar_ext_gem_init:
  101|  1.74k|void GENERATED_TMP_mrb_mruby_compar_ext_gem_init(mrb_state *mrb) {
  102|  1.74k|  gem_mrblib_mruby_compar_ext_proc_init_syms(mrb);
  103|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_compar_ext_proc);
  104|  1.74k|}
GENERATED_TMP_mrb_mruby_compar_ext_gem_final:
  106|  1.74k|void GENERATED_TMP_mrb_mruby_compar_ext_gem_final(mrb_state *mrb) {
  107|  1.74k|}
gem_init.c:gem_mrblib_mruby_compar_ext_proc_init_syms:
   96|  1.74k|{
   97|  1.74k|}

GENERATED_TMP_mrb_mruby_complex_gem_init:
  345|  1.74k|void GENERATED_TMP_mrb_mruby_complex_gem_init(mrb_state *mrb) {
  346|  1.74k|  gem_mrblib_mruby_complex_proc_init_syms(mrb);
  347|  1.74k|  mrb_mruby_complex_gem_init(mrb);
  348|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_complex_proc);
  349|  1.74k|}
GENERATED_TMP_mrb_mruby_complex_gem_final:
  351|  1.74k|void GENERATED_TMP_mrb_mruby_complex_gem_final(mrb_state *mrb) {
  352|  1.74k|  mrb_mruby_complex_gem_final(mrb);
  353|  1.74k|}
gem_init.c:gem_mrblib_mruby_complex_proc_init_syms:
  340|  1.74k|{
  341|  1.74k|}

GENERATED_TMP_mrb_mruby_data_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_data_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_data_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_data_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_data_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_data_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_dir_gem_init:
  183|  1.74k|void GENERATED_TMP_mrb_mruby_dir_gem_init(mrb_state *mrb) {
  184|  1.74k|  gem_mrblib_mruby_dir_proc_init_syms(mrb);
  185|  1.74k|  mrb_mruby_dir_gem_init(mrb);
  186|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_dir_proc);
  187|  1.74k|}
GENERATED_TMP_mrb_mruby_dir_gem_final:
  189|  1.74k|void GENERATED_TMP_mrb_mruby_dir_gem_final(mrb_state *mrb) {
  190|  1.74k|  mrb_mruby_dir_gem_final(mrb);
  191|  1.74k|}
gem_init.c:gem_mrblib_mruby_dir_proc_init_syms:
  178|  1.74k|{
  179|  1.74k|}

GENERATED_TMP_mrb_mruby_enum_ext_gem_init:
 1320|  1.74k|void GENERATED_TMP_mrb_mruby_enum_ext_gem_init(mrb_state *mrb) {
 1321|  1.74k|  gem_mrblib_mruby_enum_ext_proc_init_syms(mrb);
 1322|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_enum_ext_proc);
 1323|  1.74k|}
GENERATED_TMP_mrb_mruby_enum_ext_gem_final:
 1325|  1.74k|void GENERATED_TMP_mrb_mruby_enum_ext_gem_final(mrb_state *mrb) {
 1326|  1.74k|}
gem_init.c:gem_mrblib_mruby_enum_ext_proc_init_syms:
 1315|  1.74k|{
 1316|  1.74k|}

GENERATED_TMP_mrb_mruby_enum_lazy_gem_init:
  548|  1.74k|void GENERATED_TMP_mrb_mruby_enum_lazy_gem_init(mrb_state *mrb) {
  549|  1.74k|  gem_mrblib_mruby_enum_lazy_proc_init_syms(mrb);
  550|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_enum_lazy_proc);
  551|  1.74k|}
GENERATED_TMP_mrb_mruby_enum_lazy_gem_final:
  553|  1.74k|void GENERATED_TMP_mrb_mruby_enum_lazy_gem_final(mrb_state *mrb) {
  554|  1.74k|}
gem_init.c:gem_mrblib_mruby_enum_lazy_proc_init_syms:
  543|  1.74k|{
  544|  1.74k|}

GENERATED_TMP_mrb_mruby_enumerator_gem_init:
  633|  1.74k|void GENERATED_TMP_mrb_mruby_enumerator_gem_init(mrb_state *mrb) {
  634|  1.74k|  gem_mrblib_mruby_enumerator_proc_init_syms(mrb);
  635|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_enumerator_proc);
  636|  1.74k|}
GENERATED_TMP_mrb_mruby_enumerator_gem_final:
  638|  1.74k|void GENERATED_TMP_mrb_mruby_enumerator_gem_final(mrb_state *mrb) {
  639|  1.74k|}
gem_init.c:gem_mrblib_mruby_enumerator_proc_init_syms:
  628|  1.74k|{
  629|  1.74k|}

GENERATED_TMP_mrb_mruby_errno_gem_init:
  102|  1.74k|void GENERATED_TMP_mrb_mruby_errno_gem_init(mrb_state *mrb) {
  103|  1.74k|  gem_mrblib_mruby_errno_proc_init_syms(mrb);
  104|  1.74k|  mrb_mruby_errno_gem_init(mrb);
  105|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_errno_proc);
  106|  1.74k|}
GENERATED_TMP_mrb_mruby_errno_gem_final:
  108|  1.74k|void GENERATED_TMP_mrb_mruby_errno_gem_final(mrb_state *mrb) {
  109|  1.74k|  mrb_mruby_errno_gem_final(mrb);
  110|  1.74k|}
gem_init.c:gem_mrblib_mruby_errno_proc_init_syms:
   97|  1.74k|{
   98|  1.74k|}

GENERATED_TMP_mrb_mruby_eval_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_eval_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_eval_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_eval_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_eval_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_eval_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_fiber_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_fiber_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_fiber_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_fiber_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_fiber_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_fiber_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_hash_ext_gem_init:
  711|  1.74k|void GENERATED_TMP_mrb_mruby_hash_ext_gem_init(mrb_state *mrb) {
  712|  1.74k|  gem_mrblib_mruby_hash_ext_proc_init_syms(mrb);
  713|  1.74k|  mrb_mruby_hash_ext_gem_init(mrb);
  714|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_hash_ext_proc);
  715|  1.74k|}
GENERATED_TMP_mrb_mruby_hash_ext_gem_final:
  717|  1.74k|void GENERATED_TMP_mrb_mruby_hash_ext_gem_final(mrb_state *mrb) {
  718|  1.74k|  mrb_mruby_hash_ext_gem_final(mrb);
  719|  1.74k|}
gem_init.c:gem_mrblib_mruby_hash_ext_proc_init_syms:
  706|  1.74k|{
  707|  1.74k|}

GENERATED_TMP_mrb_mruby_io_gem_init:
  988|  1.74k|void GENERATED_TMP_mrb_mruby_io_gem_init(mrb_state *mrb) {
  989|  1.74k|  gem_mrblib_mruby_io_proc_init_syms(mrb);
  990|  1.74k|  mrb_mruby_io_gem_init(mrb);
  991|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_io_proc);
  992|  1.74k|}
GENERATED_TMP_mrb_mruby_io_gem_final:
  994|  1.74k|void GENERATED_TMP_mrb_mruby_io_gem_final(mrb_state *mrb) {
  995|  1.74k|  mrb_mruby_io_gem_final(mrb);
  996|  1.74k|}
gem_init.c:gem_mrblib_mruby_io_proc_init_syms:
  976|  1.74k|{
  977|  1.74k|  gem_mrblib_mruby_io_proc_syms_702[0] = mrb_intern_lit(mrb, "$stdout");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  978|  1.74k|  gem_mrblib_mruby_io_proc_syms_703[0] = mrb_intern_lit(mrb, "$stdout");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  979|  1.74k|  gem_mrblib_mruby_io_proc_syms_704[0] = mrb_intern_lit(mrb, "$stdout");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  980|  1.74k|  gem_mrblib_mruby_io_proc_syms_705[0] = mrb_intern_lit(mrb, "$stdin");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  981|  1.74k|  gem_mrblib_mruby_io_proc_syms_0[9] = mrb_intern_lit(mrb, "$stdin");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  982|  1.74k|  gem_mrblib_mruby_io_proc_syms_0[10] = mrb_intern_lit(mrb, "$stdout");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  983|  1.74k|  gem_mrblib_mruby_io_proc_syms_0[11] = mrb_intern_lit(mrb, "$stderr");
  ------------------
  |  | 1164|  1.74k|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  984|  1.74k|}

GENERATED_TMP_mrb_mruby_kernel_ext_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_kernel_ext_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_kernel_ext_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_kernel_ext_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_kernel_ext_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_math_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_math_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_math_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_math_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_math_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_math_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_metaprog_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_metaprog_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_metaprog_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_metaprog_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_metaprog_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_metaprog_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_method_gem_init:
  195|  1.74k|void GENERATED_TMP_mrb_mruby_method_gem_init(mrb_state *mrb) {
  196|  1.74k|  gem_mrblib_mruby_method_proc_init_syms(mrb);
  197|  1.74k|  mrb_mruby_method_gem_init(mrb);
  198|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_method_proc);
  199|  1.74k|}
GENERATED_TMP_mrb_mruby_method_gem_final:
  201|  1.74k|void GENERATED_TMP_mrb_mruby_method_gem_final(mrb_state *mrb) {
  202|  1.74k|  mrb_mruby_method_gem_final(mrb);
  203|  1.74k|}
gem_init.c:gem_mrblib_mruby_method_proc_init_syms:
  190|  1.74k|{
  191|  1.74k|}

GENERATED_TMP_mrb_mruby_numeric_ext_gem_init:
  180|  1.74k|void GENERATED_TMP_mrb_mruby_numeric_ext_gem_init(mrb_state *mrb) {
  181|  1.74k|  gem_mrblib_mruby_numeric_ext_proc_init_syms(mrb);
  182|  1.74k|  mrb_mruby_numeric_ext_gem_init(mrb);
  183|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_numeric_ext_proc);
  184|  1.74k|}
GENERATED_TMP_mrb_mruby_numeric_ext_gem_final:
  186|  1.74k|void GENERATED_TMP_mrb_mruby_numeric_ext_gem_final(mrb_state *mrb) {
  187|  1.74k|  mrb_mruby_numeric_ext_gem_final(mrb);
  188|  1.74k|}
gem_init.c:gem_mrblib_mruby_numeric_ext_proc_init_syms:
  175|  1.74k|{
  176|  1.74k|}

GENERATED_TMP_mrb_mruby_object_ext_gem_init:
   88|  1.74k|void GENERATED_TMP_mrb_mruby_object_ext_gem_init(mrb_state *mrb) {
   89|  1.74k|  gem_mrblib_mruby_object_ext_proc_init_syms(mrb);
   90|  1.74k|  mrb_mruby_object_ext_gem_init(mrb);
   91|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_object_ext_proc);
   92|  1.74k|}
GENERATED_TMP_mrb_mruby_object_ext_gem_final:
   94|  1.74k|void GENERATED_TMP_mrb_mruby_object_ext_gem_final(mrb_state *mrb) {
   95|  1.74k|  mrb_mruby_object_ext_gem_final(mrb);
   96|  1.74k|}
gem_init.c:gem_mrblib_mruby_object_ext_proc_init_syms:
   83|  1.74k|{
   84|  1.74k|}

GENERATED_TMP_mrb_mruby_objectspace_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_objectspace_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_objectspace_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_objectspace_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_objectspace_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_objectspace_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_pack_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_pack_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_pack_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_pack_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_pack_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_pack_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_print_gem_init:
  131|  1.74k|void GENERATED_TMP_mrb_mruby_print_gem_init(mrb_state *mrb) {
  132|  1.74k|  gem_mrblib_mruby_print_proc_init_syms(mrb);
  133|  1.74k|  mrb_mruby_print_gem_init(mrb);
  134|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_print_proc);
  135|  1.74k|}
GENERATED_TMP_mrb_mruby_print_gem_final:
  137|  1.74k|void GENERATED_TMP_mrb_mruby_print_gem_final(mrb_state *mrb) {
  138|  1.74k|  mrb_mruby_print_gem_final(mrb);
  139|  1.74k|}
gem_init.c:gem_mrblib_mruby_print_proc_init_syms:
  126|  1.74k|{
  127|  1.74k|}

GENERATED_TMP_mrb_mruby_proc_ext_gem_init:
  230|  1.74k|void GENERATED_TMP_mrb_mruby_proc_ext_gem_init(mrb_state *mrb) {
  231|  1.74k|  gem_mrblib_mruby_proc_ext_proc_init_syms(mrb);
  232|  1.74k|  mrb_mruby_proc_ext_gem_init(mrb);
  233|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_proc_ext_proc);
  234|  1.74k|}
GENERATED_TMP_mrb_mruby_proc_ext_gem_final:
  236|  1.74k|void GENERATED_TMP_mrb_mruby_proc_ext_gem_final(mrb_state *mrb) {
  237|  1.74k|  mrb_mruby_proc_ext_gem_final(mrb);
  238|  1.74k|}
gem_init.c:gem_mrblib_mruby_proc_ext_proc_init_syms:
  225|  1.74k|{
  226|  1.74k|}

GENERATED_TMP_mrb_mruby_random_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_random_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_random_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_random_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_random_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_random_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_range_ext_gem_init:
  177|  1.74k|void GENERATED_TMP_mrb_mruby_range_ext_gem_init(mrb_state *mrb) {
  178|  1.74k|  gem_mrblib_mruby_range_ext_proc_init_syms(mrb);
  179|  1.74k|  mrb_mruby_range_ext_gem_init(mrb);
  180|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_range_ext_proc);
  181|  1.74k|}
GENERATED_TMP_mrb_mruby_range_ext_gem_final:
  183|  1.74k|void GENERATED_TMP_mrb_mruby_range_ext_gem_final(mrb_state *mrb) {
  184|  1.74k|  mrb_mruby_range_ext_gem_final(mrb);
  185|  1.74k|}
gem_init.c:gem_mrblib_mruby_range_ext_proc_init_syms:
  172|  1.74k|{
  173|  1.74k|}

GENERATED_TMP_mrb_mruby_rational_gem_init:
  123|  1.74k|void GENERATED_TMP_mrb_mruby_rational_gem_init(mrb_state *mrb) {
  124|  1.74k|  gem_mrblib_mruby_rational_proc_init_syms(mrb);
  125|  1.74k|  mrb_mruby_rational_gem_init(mrb);
  126|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_rational_proc);
  127|  1.74k|}
GENERATED_TMP_mrb_mruby_rational_gem_final:
  129|  1.74k|void GENERATED_TMP_mrb_mruby_rational_gem_final(mrb_state *mrb) {
  130|  1.74k|  mrb_mruby_rational_gem_final(mrb);
  131|  1.74k|}
gem_init.c:gem_mrblib_mruby_rational_proc_init_syms:
  118|  1.74k|{
  119|  1.74k|}

GENERATED_TMP_mrb_mruby_set_gem_init:
 1081|  1.74k|void GENERATED_TMP_mrb_mruby_set_gem_init(mrb_state *mrb) {
 1082|  1.74k|  gem_mrblib_mruby_set_proc_init_syms(mrb);
 1083|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_set_proc);
 1084|  1.74k|}
GENERATED_TMP_mrb_mruby_set_gem_final:
 1086|  1.74k|void GENERATED_TMP_mrb_mruby_set_gem_final(mrb_state *mrb) {
 1087|  1.74k|}
gem_init.c:gem_mrblib_mruby_set_proc_init_syms:
 1076|  1.74k|{
 1077|  1.74k|}

GENERATED_TMP_mrb_mruby_socket_gem_init:
 1577|  1.74k|void GENERATED_TMP_mrb_mruby_socket_gem_init(mrb_state *mrb) {
 1578|  1.74k|  gem_mrblib_mruby_socket_proc_init_syms(mrb);
 1579|  1.74k|  mrb_mruby_socket_gem_init(mrb);
 1580|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_socket_proc);
 1581|  1.74k|}
GENERATED_TMP_mrb_mruby_socket_gem_final:
 1583|  1.74k|void GENERATED_TMP_mrb_mruby_socket_gem_final(mrb_state *mrb) {
 1584|  1.74k|  mrb_mruby_socket_gem_final(mrb);
 1585|  1.74k|}
gem_init.c:gem_mrblib_mruby_socket_proc_init_syms:
 1572|  1.74k|{
 1573|  1.74k|}

GENERATED_TMP_mrb_mruby_sprintf_gem_init:
   75|  1.74k|void GENERATED_TMP_mrb_mruby_sprintf_gem_init(mrb_state *mrb) {
   76|  1.74k|  gem_mrblib_mruby_sprintf_proc_init_syms(mrb);
   77|  1.74k|  mrb_mruby_sprintf_gem_init(mrb);
   78|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_sprintf_proc);
   79|  1.74k|}
GENERATED_TMP_mrb_mruby_sprintf_gem_final:
   81|  1.74k|void GENERATED_TMP_mrb_mruby_sprintf_gem_final(mrb_state *mrb) {
   82|  1.74k|  mrb_mruby_sprintf_gem_final(mrb);
   83|  1.74k|}
gem_init.c:gem_mrblib_mruby_sprintf_proc_init_syms:
   70|  1.74k|{
   71|  1.74k|}

GENERATED_TMP_mrb_mruby_string_ext_gem_init:
  600|  1.74k|void GENERATED_TMP_mrb_mruby_string_ext_gem_init(mrb_state *mrb) {
  601|  1.74k|  gem_mrblib_mruby_string_ext_proc_init_syms(mrb);
  602|  1.74k|  mrb_mruby_string_ext_gem_init(mrb);
  603|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_string_ext_proc);
  604|  1.74k|}
GENERATED_TMP_mrb_mruby_string_ext_gem_final:
  606|  1.74k|void GENERATED_TMP_mrb_mruby_string_ext_gem_final(mrb_state *mrb) {
  607|  1.74k|  mrb_mruby_string_ext_gem_final(mrb);
  608|  1.74k|}
gem_init.c:gem_mrblib_mruby_string_ext_proc_init_syms:
  595|  1.74k|{
  596|  1.74k|}

GENERATED_TMP_mrb_mruby_struct_gem_init:
  227|  1.74k|void GENERATED_TMP_mrb_mruby_struct_gem_init(mrb_state *mrb) {
  228|  1.74k|  gem_mrblib_mruby_struct_proc_init_syms(mrb);
  229|  1.74k|  mrb_mruby_struct_gem_init(mrb);
  230|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_struct_proc);
  231|  1.74k|}
GENERATED_TMP_mrb_mruby_struct_gem_final:
  233|  1.74k|void GENERATED_TMP_mrb_mruby_struct_gem_final(mrb_state *mrb) {
  234|  1.74k|  mrb_mruby_struct_gem_final(mrb);
  235|  1.74k|}
gem_init.c:gem_mrblib_mruby_struct_proc_init_syms:
  222|  1.74k|{
  223|  1.74k|}

GENERATED_TMP_mrb_mruby_symbol_ext_gem_init:
  147|  1.74k|void GENERATED_TMP_mrb_mruby_symbol_ext_gem_init(mrb_state *mrb) {
  148|  1.74k|  gem_mrblib_mruby_symbol_ext_proc_init_syms(mrb);
  149|  1.74k|  mrb_mruby_symbol_ext_gem_init(mrb);
  150|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_symbol_ext_proc);
  151|  1.74k|}
GENERATED_TMP_mrb_mruby_symbol_ext_gem_final:
  153|  1.74k|void GENERATED_TMP_mrb_mruby_symbol_ext_gem_final(mrb_state *mrb) {
  154|  1.74k|  mrb_mruby_symbol_ext_gem_final(mrb);
  155|  1.74k|}
gem_init.c:gem_mrblib_mruby_symbol_ext_proc_init_syms:
  142|  1.74k|{
  143|  1.74k|}

GENERATED_TMP_mrb_mruby_time_gem_init:
   15|  1.74k|void GENERATED_TMP_mrb_mruby_time_gem_init(mrb_state *mrb) {
   16|  1.74k|  mrb_mruby_time_gem_init(mrb);
   17|  1.74k|}
GENERATED_TMP_mrb_mruby_time_gem_final:
   19|  1.74k|void GENERATED_TMP_mrb_mruby_time_gem_final(mrb_state *mrb) {
   20|  1.74k|  mrb_mruby_time_gem_final(mrb);
   21|  1.74k|}

GENERATED_TMP_mrb_mruby_toplevel_ext_gem_init:
   98|  1.74k|void GENERATED_TMP_mrb_mruby_toplevel_ext_gem_init(mrb_state *mrb) {
   99|  1.74k|  gem_mrblib_mruby_toplevel_ext_proc_init_syms(mrb);
  100|  1.74k|  mrb_load_proc(mrb, gem_mrblib_mruby_toplevel_ext_proc);
  101|  1.74k|}
GENERATED_TMP_mrb_mruby_toplevel_ext_gem_final:
  103|  1.74k|void GENERATED_TMP_mrb_mruby_toplevel_ext_gem_final(mrb_state *mrb) {
  104|  1.74k|}
gem_init.c:gem_mrblib_mruby_toplevel_ext_proc_init_syms:
   93|  1.74k|{
   94|  1.74k|}

mrb_init_mrblib:
 2291|  1.74k|{
 2292|  1.74k|  mrblib_proc_init_syms(mrb);
 2293|  1.74k|  mrb_load_proc(mrb, mrblib_proc);
 2294|  1.74k|}
mrblib.c:mrblib_proc_init_syms:
 2287|  1.74k|{
 2288|  1.74k|}

_Z36descriptor_table_ruby_2eproto_getterv:
  768|      1|PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_ruby_2eproto_getter() {
  769|      1|  return &descriptor_table_ruby_2eproto;
  770|      1|}
_ZN11ruby_fuzzer6VarRefC2EPN6google8protobuf5ArenaE:
 1049|  73.2k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1050|  73.2k|  SharedCtor(arena);
 1051|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.VarRef)
 1052|  73.2k|}
_ZN11ruby_fuzzer6VarRefD2Ev:
 1070|  73.2k|VarRef::~VarRef() {
 1071|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.VarRef)
 1072|  73.2k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1072:13): [True: 0, False: 73.2k]
  ------------------
 1073|      0|  (void)arena;
 1074|      0|    return;
 1075|      0|  }
 1076|  73.2k|  SharedDtor();
 1077|  73.2k|}
_ZNK11ruby_fuzzer6VarRef11GetMetadataEv:
 1218|   656k|::PROTOBUF_NAMESPACE_ID::Metadata VarRef::GetMetadata() const {
 1219|   656k|  return ::_pbi::AssignDescriptors(
 1220|   656k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 1221|   656k|      file_level_metadata_ruby_2eproto[0]);
 1222|   656k|}
_ZN11ruby_fuzzer7ArrTypeC2EPN6google8protobuf5ArenaE:
 1230|  58.5k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1231|  58.5k|  SharedCtor(arena);
 1232|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.ArrType)
 1233|  58.5k|}
_ZN11ruby_fuzzer7ArrTypeD2Ev:
 1253|  58.5k|ArrType::~ArrType() {
 1254|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.ArrType)
 1255|  58.5k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1255:13): [True: 0, False: 58.5k]
  ------------------
 1256|      0|  (void)arena;
 1257|      0|    return;
 1258|      0|  }
 1259|  58.5k|  SharedDtor();
 1260|  58.5k|}
_ZN11ruby_fuzzer7ArrType5ClearEv:
 1271|  4.82k|void ArrType::Clear() {
 1272|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.ArrType)
 1273|  4.82k|  ::uint32_t cached_has_bits = 0;
 1274|       |  // Prevent compiler warnings about cached_has_bits being unused
 1275|  4.82k|  (void) cached_has_bits;
 1276|       |
 1277|  4.82k|  _impl_.elements_.Clear();
 1278|  4.82k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1279|  4.82k|}
_ZNK11ruby_fuzzer7ArrType12GetClassDataEv:
 1368|  7.23k|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ArrType::GetClassData() const { return &_class_data_; }
_ZN11ruby_fuzzer7ArrType9MergeImplERN6google8protobuf7MessageERKS3_:
 1371|  2.41k|void ArrType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 1372|  2.41k|  auto* const _this = static_cast<ArrType*>(&to_msg);
 1373|  2.41k|  auto& from = static_cast<const ArrType&>(from_msg);
 1374|       |  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.ArrType)
 1375|  2.41k|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|  2.41k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  2.41k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  2.41k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.41k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1376|  2.41k|  ::uint32_t cached_has_bits = 0;
 1377|  2.41k|  (void) cached_has_bits;
 1378|       |
 1379|  2.41k|  _this->_impl_.elements_.MergeFrom(from._impl_.elements_);
 1380|  2.41k|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 1381|  2.41k|}
_ZNK11ruby_fuzzer7ArrType11GetMetadataEv:
 1400|  1.12M|::PROTOBUF_NAMESPACE_ID::Metadata ArrType::GetMetadata() const {
 1401|  1.12M|  return ::_pbi::AssignDescriptors(
 1402|  1.12M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 1403|  1.12M|      file_level_metadata_ruby_2eproto[1]);
 1404|  1.12M|}
_ZN11ruby_fuzzer6KVPairC2EPN6google8protobuf5ArenaE:
 1424|   129k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1425|   129k|  SharedCtor(arena);
 1426|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.KVPair)
 1427|   129k|}
_ZN11ruby_fuzzer6KVPairD2Ev:
 1477|   129k|KVPair::~KVPair() {
 1478|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.KVPair)
 1479|   129k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1479:13): [True: 0, False: 129k]
  ------------------
 1480|      0|  (void)arena;
 1481|      0|    return;
 1482|      0|  }
 1483|   129k|  SharedDtor();
 1484|   129k|}
_ZNK11ruby_fuzzer6KVPair11GetMetadataEv:
 1695|  1.44M|::PROTOBUF_NAMESPACE_ID::Metadata KVPair::GetMetadata() const {
 1696|  1.44M|  return ::_pbi::AssignDescriptors(
 1697|  1.44M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 1698|  1.44M|      file_level_metadata_ruby_2eproto[2]);
 1699|  1.44M|}
_ZN11ruby_fuzzer8HashTypeC2EPN6google8protobuf5ArenaE:
 1707|  20.6k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 1708|  20.6k|  SharedCtor(arena);
 1709|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.HashType)
 1710|  20.6k|}
_ZN11ruby_fuzzer8HashTypeD2Ev:
 1730|  20.6k|HashType::~HashType() {
 1731|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.HashType)
 1732|  20.6k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1732:13): [True: 0, False: 20.6k]
  ------------------
 1733|      0|  (void)arena;
 1734|      0|    return;
 1735|      0|  }
 1736|  20.6k|  SharedDtor();
 1737|  20.6k|}
_ZN11ruby_fuzzer8HashType5ClearEv:
 1748|     16|void HashType::Clear() {
 1749|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.HashType)
 1750|     16|  ::uint32_t cached_has_bits = 0;
 1751|       |  // Prevent compiler warnings about cached_has_bits being unused
 1752|     16|  (void) cached_has_bits;
 1753|       |
 1754|     16|  _impl_.keyval_.Clear();
 1755|     16|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 1756|     16|}
_ZNK11ruby_fuzzer8HashType12GetClassDataEv:
 1845|     24|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HashType::GetClassData() const { return &_class_data_; }
_ZN11ruby_fuzzer8HashType9MergeImplERN6google8protobuf7MessageERKS3_:
 1848|      8|void HashType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 1849|      8|  auto* const _this = static_cast<HashType*>(&to_msg);
 1850|      8|  auto& from = static_cast<const HashType&>(from_msg);
 1851|       |  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.HashType)
 1852|      8|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|      8|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|      8|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      8|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      8|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1853|      8|  ::uint32_t cached_has_bits = 0;
 1854|      8|  (void) cached_has_bits;
 1855|       |
 1856|      8|  _this->_impl_.keyval_.MergeFrom(from._impl_.keyval_);
 1857|      8|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 1858|      8|}
_ZNK11ruby_fuzzer8HashType11GetMetadataEv:
 1879|   526k|::PROTOBUF_NAMESPACE_ID::Metadata HashType::GetMetadata() const {
 1880|   526k|  return ::_pbi::AssignDescriptors(
 1881|   526k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 1882|   526k|      file_level_metadata_ruby_2eproto[3]);
 1883|   526k|}
_ZN11ruby_fuzzer9MathConstC2EPN6google8protobuf5ArenaE:
 2180|  3.09k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 2181|  3.09k|  SharedCtor(arena);
 2182|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.MathConst)
 2183|  3.09k|}
_ZN11ruby_fuzzer9MathConstD2Ev:
 2201|  3.09k|MathConst::~MathConst() {
 2202|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.MathConst)
 2203|  3.09k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (2203:13): [True: 0, False: 3.09k]
  ------------------
 2204|      0|  (void)arena;
 2205|      0|    return;
 2206|      0|  }
 2207|  3.09k|  SharedDtor();
 2208|  3.09k|}
_ZNK11ruby_fuzzer9MathConst11GetMetadataEv:
 2352|  27.7k|::PROTOBUF_NAMESPACE_ID::Metadata MathConst::GetMetadata() const {
 2353|  27.7k|  return ::_pbi::AssignDescriptors(
 2354|  27.7k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 2355|  27.7k|      file_level_metadata_ruby_2eproto[5]);
 2356|  27.7k|}
_ZN11ruby_fuzzer5ConstC2EPN6google8protobuf5ArenaE:
 2366|   291k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 2367|   291k|  SharedCtor(arena);
 2368|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Const)
 2369|   291k|}
_ZN11ruby_fuzzer5ConstD2Ev:
 2406|   291k|Const::~Const() {
 2407|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Const)
 2408|   291k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (2408:13): [True: 0, False: 291k]
  ------------------
 2409|      0|  (void)arena;
 2410|      0|    return;
 2411|      0|  }
 2412|   291k|  SharedDtor();
 2413|   291k|}
_ZN11ruby_fuzzer5Const17clear_const_oneofEv:
 2426|  44.7k|void Const::clear_const_oneof() {
 2427|       |// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.Const)
 2428|  44.7k|  switch (const_oneof_case()) {
  ------------------
  |  Branch (2428:11): [True: 0, False: 44.7k]
  ------------------
 2429|  32.3k|    case kIntLit: {
  ------------------
  |  Branch (2429:5): [True: 32.3k, False: 12.3k]
  ------------------
 2430|       |      // No need to clear
 2431|  32.3k|      break;
 2432|      0|    }
 2433|  12.3k|    case kBoolVal: {
  ------------------
  |  Branch (2433:5): [True: 12.3k, False: 32.3k]
  ------------------
 2434|       |      // No need to clear
 2435|  12.3k|      break;
 2436|      0|    }
 2437|      0|    case CONST_ONEOF_NOT_SET: {
  ------------------
  |  Branch (2437:5): [True: 0, False: 44.7k]
  ------------------
 2438|      0|      break;
 2439|      0|    }
 2440|  44.7k|  }
 2441|  44.7k|  _impl_._oneof_case_[0] = CONST_ONEOF_NOT_SET;
 2442|  44.7k|}
_ZNK11ruby_fuzzer5Const11GetMetadataEv:
 2607|  1.84M|::PROTOBUF_NAMESPACE_ID::Metadata Const::GetMetadata() const {
 2608|  1.84M|  return ::_pbi::AssignDescriptors(
 2609|  1.84M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 2610|  1.84M|      file_level_metadata_ruby_2eproto[6]);
 2611|  1.84M|}
_ZN11ruby_fuzzer8BinaryOpC2EPN6google8protobuf5ArenaE:
 2644|   131k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 2645|   131k|  SharedCtor(arena);
 2646|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.BinaryOp)
 2647|   131k|}
_ZN11ruby_fuzzer8BinaryOpD2Ev:
 2682|   131k|BinaryOp::~BinaryOp() {
 2683|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.BinaryOp)
 2684|   131k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (2684:13): [True: 0, False: 131k]
  ------------------
 2685|      0|  (void)arena;
 2686|      0|    return;
 2687|      0|  }
 2688|   131k|  SharedDtor();
 2689|   131k|}
_ZNK11ruby_fuzzer8BinaryOp11GetMetadataEv:
 2940|  2.10M|::PROTOBUF_NAMESPACE_ID::Metadata BinaryOp::GetMetadata() const {
 2941|  2.10M|  return ::_pbi::AssignDescriptors(
 2942|  2.10M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 2943|  2.10M|      file_level_metadata_ruby_2eproto[7]);
 2944|  2.10M|}
_ZN11ruby_fuzzer6RvalueC2EPN6google8protobuf5ArenaE:
 3014|   580k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 3015|   580k|  SharedCtor(arena);
 3016|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Rvalue)
 3017|   580k|}
_ZN11ruby_fuzzer6RvalueD2Ev:
 3061|   580k|Rvalue::~Rvalue() {
 3062|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Rvalue)
 3063|   580k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3063:13): [True: 0, False: 580k]
  ------------------
 3064|      0|  (void)arena;
 3065|      0|    return;
 3066|      0|  }
 3067|   580k|  SharedDtor();
 3068|   580k|}
_ZN11ruby_fuzzer6Rvalue18clear_rvalue_oneofEv:
 3081|   249k|void Rvalue::clear_rvalue_oneof() {
 3082|       |// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.Rvalue)
 3083|   249k|  switch (rvalue_oneof_case()) {
  ------------------
  |  Branch (3083:11): [True: 0, False: 249k]
  ------------------
 3084|  73.2k|    case kVarref: {
  ------------------
  |  Branch (3084:5): [True: 73.2k, False: 176k]
  ------------------
 3085|  73.2k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (3085:11): [True: 73.2k, False: 0]
  ------------------
 3086|  73.2k|        delete _impl_.rvalue_oneof_.varref_;
 3087|  73.2k|      }
 3088|  73.2k|      break;
 3089|      0|    }
 3090|  38.4k|    case kCons: {
  ------------------
  |  Branch (3090:5): [True: 38.4k, False: 211k]
  ------------------
 3091|  38.4k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (3091:11): [True: 38.4k, False: 0]
  ------------------
 3092|  38.4k|        delete _impl_.rvalue_oneof_.cons_;
 3093|  38.4k|      }
 3094|  38.4k|      break;
 3095|      0|    }
 3096|   131k|    case kBinop: {
  ------------------
  |  Branch (3096:5): [True: 131k, False: 118k]
  ------------------
 3097|   131k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (3097:11): [True: 131k, False: 0]
  ------------------
 3098|   131k|        delete _impl_.rvalue_oneof_.binop_;
 3099|   131k|      }
 3100|   131k|      break;
 3101|      0|    }
 3102|  6.88k|    case RVALUE_ONEOF_NOT_SET: {
  ------------------
  |  Branch (3102:5): [True: 6.88k, False: 242k]
  ------------------
 3103|  6.88k|      break;
 3104|      0|    }
 3105|   249k|  }
 3106|   249k|  _impl_._oneof_case_[0] = RVALUE_ONEOF_NOT_SET;
 3107|   249k|}
_ZN11ruby_fuzzer6Rvalue5ClearEv:
 3110|  6.88k|void Rvalue::Clear() {
 3111|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Rvalue)
 3112|  6.88k|  ::uint32_t cached_has_bits = 0;
 3113|       |  // Prevent compiler warnings about cached_has_bits being unused
 3114|  6.88k|  (void) cached_has_bits;
 3115|       |
 3116|  6.88k|  clear_rvalue_oneof();
 3117|  6.88k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 3118|  6.88k|}
_ZNK11ruby_fuzzer6Rvalue12GetClassDataEv:
 3252|  10.3k|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Rvalue::GetClassData() const { return &_class_data_; }
_ZN11ruby_fuzzer6Rvalue9MergeImplERN6google8protobuf7MessageERKS3_:
 3255|  3.44k|void Rvalue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 3256|  3.44k|  auto* const _this = static_cast<Rvalue*>(&to_msg);
 3257|  3.44k|  auto& from = static_cast<const Rvalue&>(from_msg);
 3258|       |  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Rvalue)
 3259|  3.44k|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|  3.44k|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|  3.44k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  3.44k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  3.44k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3260|  3.44k|  ::uint32_t cached_has_bits = 0;
 3261|  3.44k|  (void) cached_has_bits;
 3262|       |
 3263|  3.44k|  switch (from.rvalue_oneof_case()) {
  ------------------
  |  Branch (3263:11): [True: 0, False: 3.44k]
  ------------------
 3264|      0|    case kVarref: {
  ------------------
  |  Branch (3264:5): [True: 0, False: 3.44k]
  ------------------
 3265|      0|      _this->_internal_mutable_varref()->::ruby_fuzzer::VarRef::MergeFrom(
 3266|      0|          from._internal_varref());
 3267|      0|      break;
 3268|      0|    }
 3269|      0|    case kCons: {
  ------------------
  |  Branch (3269:5): [True: 0, False: 3.44k]
  ------------------
 3270|      0|      _this->_internal_mutable_cons()->::ruby_fuzzer::Const::MergeFrom(
 3271|      0|          from._internal_cons());
 3272|      0|      break;
 3273|      0|    }
 3274|      0|    case kBinop: {
  ------------------
  |  Branch (3274:5): [True: 0, False: 3.44k]
  ------------------
 3275|      0|      _this->_internal_mutable_binop()->::ruby_fuzzer::BinaryOp::MergeFrom(
 3276|      0|          from._internal_binop());
 3277|      0|      break;
 3278|      0|    }
 3279|  3.44k|    case RVALUE_ONEOF_NOT_SET: {
  ------------------
  |  Branch (3279:5): [True: 3.44k, False: 0]
  ------------------
 3280|  3.44k|      break;
 3281|      0|    }
 3282|  3.44k|  }
 3283|  3.44k|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 3284|  3.44k|}
_ZNK11ruby_fuzzer6Rvalue11GetMetadataEv:
 3324|  4.16M|::PROTOBUF_NAMESPACE_ID::Metadata Rvalue::GetMetadata() const {
 3325|  4.16M|  return ::_pbi::AssignDescriptors(
 3326|  4.16M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 3327|  4.16M|      file_level_metadata_ruby_2eproto[8]);
 3328|  4.16M|}
_ZN11ruby_fuzzer19AssignmentStatementC2EPN6google8protobuf5ArenaE:
 3350|   215k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 3351|   215k|  SharedCtor(arena);
 3352|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.AssignmentStatement)
 3353|   215k|}
_ZN11ruby_fuzzer19AssignmentStatementD2Ev:
 3378|   215k|AssignmentStatement::~AssignmentStatement() {
 3379|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.AssignmentStatement)
 3380|   215k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3380:13): [True: 0, False: 215k]
  ------------------
 3381|      0|  (void)arena;
 3382|      0|    return;
 3383|      0|  }
 3384|   215k|  SharedDtor();
 3385|   215k|}
_ZNK11ruby_fuzzer19AssignmentStatement11GetMetadataEv:
 3534|  1.92M|::PROTOBUF_NAMESPACE_ID::Metadata AssignmentStatement::GetMetadata() const {
 3535|  1.92M|  return ::_pbi::AssignDescriptors(
 3536|  1.92M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 3537|  1.92M|      file_level_metadata_ruby_2eproto[9]);
 3538|  1.92M|}
_ZN11ruby_fuzzer6IfElseC2EPN6google8protobuf5ArenaE:
 3576|  17.5k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 3577|  17.5k|  SharedCtor(arena);
 3578|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.IfElse)
 3579|  17.5k|}
_ZN11ruby_fuzzer6IfElseD2Ev:
 3614|  17.5k|IfElse::~IfElse() {
 3615|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.IfElse)
 3616|  17.5k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3616:13): [True: 0, False: 17.5k]
  ------------------
 3617|      0|  (void)arena;
 3618|      0|    return;
 3619|      0|  }
 3620|  17.5k|  SharedDtor();
 3621|  17.5k|}
_ZNK11ruby_fuzzer6IfElse11GetMetadataEv:
 3876|   262k|::PROTOBUF_NAMESPACE_ID::Metadata IfElse::GetMetadata() const {
 3877|   262k|  return ::_pbi::AssignDescriptors(
 3878|   262k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 3879|   262k|      file_level_metadata_ruby_2eproto[10]);
 3880|   262k|}
_ZN11ruby_fuzzer7TernaryC2EPN6google8protobuf5ArenaE:
 3918|  8.65k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 3919|  8.65k|  SharedCtor(arena);
 3920|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Ternary)
 3921|  8.65k|}
_ZN11ruby_fuzzer7TernaryD2Ev:
 3956|  8.65k|Ternary::~Ternary() {
 3957|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Ternary)
 3958|  8.65k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3958:13): [True: 0, False: 8.65k]
  ------------------
 3959|      0|  (void)arena;
 3960|      0|    return;
 3961|      0|  }
 3962|  8.65k|  SharedDtor();
 3963|  8.65k|}
_ZNK11ruby_fuzzer7Ternary11GetMetadataEv:
 4218|   129k|::PROTOBUF_NAMESPACE_ID::Metadata Ternary::GetMetadata() const {
 4219|   129k|  return ::_pbi::AssignDescriptors(
 4220|   129k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 4221|   129k|      file_level_metadata_ruby_2eproto[11]);
 4222|   129k|}
_ZN11ruby_fuzzer11ObjectSpaceC2EPN6google8protobuf5ArenaE:
 4247|  20.6k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 4248|  20.6k|  SharedCtor(arena);
 4249|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.ObjectSpace)
 4250|  20.6k|}
_ZN11ruby_fuzzer11ObjectSpaceD2Ev:
 4280|  20.6k|ObjectSpace::~ObjectSpace() {
 4281|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.ObjectSpace)
 4282|  20.6k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (4282:13): [True: 0, False: 20.6k]
  ------------------
 4283|      0|  (void)arena;
 4284|      0|    return;
 4285|      0|  }
 4286|  20.6k|  SharedDtor();
 4287|  20.6k|}
_ZNK11ruby_fuzzer11ObjectSpace11GetMetadataEv:
 4498|   247k|::PROTOBUF_NAMESPACE_ID::Metadata ObjectSpace::GetMetadata() const {
 4499|   247k|  return ::_pbi::AssignDescriptors(
 4500|   247k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 4501|   247k|      file_level_metadata_ruby_2eproto[12]);
 4502|   247k|}
_ZN11ruby_fuzzer4TimeC2EPN6google8protobuf5ArenaE:
 4522|  10.2k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 4523|  10.2k|  SharedCtor(arena);
 4524|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Time)
 4525|  10.2k|}
_ZN11ruby_fuzzer4TimeD2Ev:
 4545|  10.2k|Time::~Time() {
 4546|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Time)
 4547|  10.2k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (4547:13): [True: 0, False: 10.2k]
  ------------------
 4548|      0|  (void)arena;
 4549|      0|    return;
 4550|      0|  }
 4551|  10.2k|  SharedDtor();
 4552|  10.2k|}
_ZNK11ruby_fuzzer4Time11GetMetadataEv:
 4754|   123k|::PROTOBUF_NAMESPACE_ID::Metadata Time::GetMetadata() const {
 4755|   123k|  return ::_pbi::AssignDescriptors(
 4756|   123k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 4757|   123k|      file_level_metadata_ruby_2eproto[13]);
 4758|   123k|}
_ZN11ruby_fuzzer5ArrayC2EPN6google8protobuf5ArenaE:
 4791|  56.1k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 4792|  56.1k|  SharedCtor(arena);
 4793|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Array)
 4794|  56.1k|}
_ZN11ruby_fuzzer5ArrayD2Ev:
 4829|  56.1k|Array::~Array() {
 4830|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Array)
 4831|  56.1k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (4831:13): [True: 0, False: 56.1k]
  ------------------
 4832|      0|  (void)arena;
 4833|      0|    return;
 4834|      0|  }
 4835|  56.1k|  SharedDtor();
 4836|  56.1k|}
_ZNK11ruby_fuzzer5Array11GetMetadataEv:
 5084|   831k|::PROTOBUF_NAMESPACE_ID::Metadata Array::GetMetadata() const {
 5085|   831k|  return ::_pbi::AssignDescriptors(
 5086|   831k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 5087|   831k|      file_level_metadata_ruby_2eproto[14]);
 5088|   831k|}
_ZN11ruby_fuzzer8MathTypeC2EPN6google8protobuf5ArenaE:
 5138|  9.45k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 5139|  9.45k|  SharedCtor(arena);
 5140|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.MathType)
 5141|  9.45k|}
_ZN11ruby_fuzzer8MathTypeD2Ev:
 5180|  9.45k|MathType::~MathType() {
 5181|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.MathType)
 5182|  9.45k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5182:13): [True: 0, False: 9.45k]
  ------------------
 5183|      0|  (void)arena;
 5184|      0|    return;
 5185|      0|  }
 5186|  9.45k|  SharedDtor();
 5187|  9.45k|}
_ZN11ruby_fuzzer8MathType20clear_math_arg_oneofEv:
 5200|  4.70k|void MathType::clear_math_arg_oneof() {
 5201|       |// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.MathType)
 5202|  4.70k|  switch (math_arg_oneof_case()) {
  ------------------
  |  Branch (5202:11): [True: 0, False: 4.70k]
  ------------------
 5203|  1.40k|    case kMathRval: {
  ------------------
  |  Branch (5203:5): [True: 1.40k, False: 3.30k]
  ------------------
 5204|  1.40k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5204:11): [True: 1.40k, False: 0]
  ------------------
 5205|  1.40k|        delete _impl_.math_arg_oneof_.math_rval_;
 5206|  1.40k|      }
 5207|  1.40k|      break;
 5208|      0|    }
 5209|  3.09k|    case kMathConst: {
  ------------------
  |  Branch (5209:5): [True: 3.09k, False: 1.61k]
  ------------------
 5210|  3.09k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5210:11): [True: 3.09k, False: 0]
  ------------------
 5211|  3.09k|        delete _impl_.math_arg_oneof_.math_const_;
 5212|  3.09k|      }
 5213|  3.09k|      break;
 5214|      0|    }
 5215|    210|    case MATH_ARG_ONEOF_NOT_SET: {
  ------------------
  |  Branch (5215:5): [True: 210, False: 4.49k]
  ------------------
 5216|    210|      break;
 5217|      0|    }
 5218|  4.70k|  }
 5219|  4.70k|  _impl_._oneof_case_[0] = MATH_ARG_ONEOF_NOT_SET;
 5220|  4.70k|}
_ZN11ruby_fuzzer8MathType5ClearEv:
 5223|    210|void MathType::Clear() {
 5224|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.MathType)
 5225|    210|  ::uint32_t cached_has_bits = 0;
 5226|       |  // Prevent compiler warnings about cached_has_bits being unused
 5227|    210|  (void) cached_has_bits;
 5228|       |
 5229|    210|  clear_math_arg_oneof();
 5230|    210|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 5231|    210|}
_ZNK11ruby_fuzzer8MathType12GetClassDataEv:
 5343|    315|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MathType::GetClassData() const { return &_class_data_; }
_ZN11ruby_fuzzer8MathType9MergeImplERN6google8protobuf7MessageERKS3_:
 5346|    105|void MathType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 5347|    105|  auto* const _this = static_cast<MathType*>(&to_msg);
 5348|    105|  auto& from = static_cast<const MathType&>(from_msg);
 5349|       |  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.MathType)
 5350|    105|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|    105|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|    105|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    105|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    105|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5351|    105|  ::uint32_t cached_has_bits = 0;
 5352|    105|  (void) cached_has_bits;
 5353|       |
 5354|    105|  switch (from.math_arg_oneof_case()) {
  ------------------
  |  Branch (5354:11): [True: 0, False: 105]
  ------------------
 5355|      0|    case kMathRval: {
  ------------------
  |  Branch (5355:5): [True: 0, False: 105]
  ------------------
 5356|      0|      _this->_internal_mutable_math_rval()->::ruby_fuzzer::Rvalue::MergeFrom(
 5357|      0|          from._internal_math_rval());
 5358|      0|      break;
 5359|      0|    }
 5360|      0|    case kMathConst: {
  ------------------
  |  Branch (5360:5): [True: 0, False: 105]
  ------------------
 5361|      0|      _this->_internal_mutable_math_const()->::ruby_fuzzer::MathConst::MergeFrom(
 5362|      0|          from._internal_math_const());
 5363|      0|      break;
 5364|      0|    }
 5365|    105|    case MATH_ARG_ONEOF_NOT_SET: {
  ------------------
  |  Branch (5365:5): [True: 105, False: 0]
  ------------------
 5366|    105|      break;
 5367|      0|    }
 5368|    105|  }
 5369|    105|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 5370|    105|}
_ZNK11ruby_fuzzer8MathType11GetMetadataEv:
 5407|  68.3k|::PROTOBUF_NAMESPACE_ID::Metadata MathType::GetMetadata() const {
 5408|  68.3k|  return ::_pbi::AssignDescriptors(
 5409|  68.3k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 5410|  68.3k|      file_level_metadata_ruby_2eproto[15]);
 5411|  68.3k|}
_ZN11ruby_fuzzer7MathOpsC2EPN6google8protobuf5ArenaE:
 5436|  9.47k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 5437|  9.47k|  SharedCtor(arena);
 5438|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.MathOps)
 5439|  9.47k|}
_ZN11ruby_fuzzer7MathOpsD2Ev:
 5469|  9.47k|MathOps::~MathOps() {
 5470|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.MathOps)
 5471|  9.47k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5471:13): [True: 0, False: 9.47k]
  ------------------
 5472|      0|  (void)arena;
 5473|      0|    return;
 5474|      0|  }
 5475|  9.47k|  SharedDtor();
 5476|  9.47k|}
_ZNK11ruby_fuzzer7MathOps11GetMetadataEv:
 5687|   111k|::PROTOBUF_NAMESPACE_ID::Metadata MathOps::GetMetadata() const {
 5688|   111k|  return ::_pbi::AssignDescriptors(
 5689|   111k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 5690|   111k|      file_level_metadata_ruby_2eproto[16]);
 5691|   111k|}
_ZN11ruby_fuzzer12BuiltinFuncsC2EPN6google8protobuf5ArenaE:
 5781|   119k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 5782|   119k|  SharedCtor(arena);
 5783|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.BuiltinFuncs)
 5784|   119k|}
_ZN11ruby_fuzzer12BuiltinFuncsD2Ev:
 5833|   119k|BuiltinFuncs::~BuiltinFuncs() {
 5834|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.BuiltinFuncs)
 5835|   119k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5835:13): [True: 0, False: 119k]
  ------------------
 5836|      0|  (void)arena;
 5837|      0|    return;
 5838|      0|  }
 5839|   119k|  SharedDtor();
 5840|   119k|}
_ZN11ruby_fuzzer12BuiltinFuncs18clear_bifunc_oneofEv:
 5853|  96.5k|void BuiltinFuncs::clear_bifunc_oneof() {
 5854|       |// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.BuiltinFuncs)
 5855|  96.5k|  switch (bifunc_oneof_case()) {
  ------------------
  |  Branch (5855:11): [True: 0, False: 96.5k]
  ------------------
 5856|  20.6k|    case kOs: {
  ------------------
  |  Branch (5856:5): [True: 20.6k, False: 75.9k]
  ------------------
 5857|  20.6k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5857:11): [True: 20.6k, False: 0]
  ------------------
 5858|  20.6k|        delete _impl_.bifunc_oneof_.os_;
 5859|  20.6k|      }
 5860|  20.6k|      break;
 5861|      0|    }
 5862|  10.2k|    case kTime: {
  ------------------
  |  Branch (5862:5): [True: 10.2k, False: 86.3k]
  ------------------
 5863|  10.2k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5863:11): [True: 10.2k, False: 0]
  ------------------
 5864|  10.2k|        delete _impl_.bifunc_oneof_.time_;
 5865|  10.2k|      }
 5866|  10.2k|      break;
 5867|      0|    }
 5868|  56.1k|    case kArr: {
  ------------------
  |  Branch (5868:5): [True: 56.1k, False: 40.4k]
  ------------------
 5869|  56.1k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5869:11): [True: 56.1k, False: 0]
  ------------------
 5870|  56.1k|        delete _impl_.bifunc_oneof_.arr_;
 5871|  56.1k|      }
 5872|  56.1k|      break;
 5873|      0|    }
 5874|  9.47k|    case kMops: {
  ------------------
  |  Branch (5874:5): [True: 9.47k, False: 87.1k]
  ------------------
 5875|  9.47k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5875:11): [True: 9.47k, False: 0]
  ------------------
 5876|  9.47k|        delete _impl_.bifunc_oneof_.mops_;
 5877|  9.47k|      }
 5878|  9.47k|      break;
 5879|      0|    }
 5880|      0|    case BIFUNC_ONEOF_NOT_SET: {
  ------------------
  |  Branch (5880:5): [True: 0, False: 96.5k]
  ------------------
 5881|      0|      break;
 5882|      0|    }
 5883|  96.5k|  }
 5884|  96.5k|  _impl_._oneof_case_[0] = BIFUNC_ONEOF_NOT_SET;
 5885|  96.5k|}
_ZNK11ruby_fuzzer12BuiltinFuncs11GetMetadataEv:
 6138|  1.00M|::PROTOBUF_NAMESPACE_ID::Metadata BuiltinFuncs::GetMetadata() const {
 6139|  1.00M|  return ::_pbi::AssignDescriptors(
 6140|  1.00M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 6141|  1.00M|      file_level_metadata_ruby_2eproto[17]);
 6142|  1.00M|}
_ZN11ruby_fuzzer9StatementC2EPN6google8protobuf5ArenaE:
 6252|   554k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 6253|   554k|  SharedCtor(arena);
 6254|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Statement)
 6255|   554k|}
_ZN11ruby_fuzzer9StatementD2Ev:
 6309|   554k|Statement::~Statement() {
 6310|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Statement)
 6311|   554k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (6311:13): [True: 0, False: 554k]
  ------------------
 6312|      0|  (void)arena;
 6313|      0|    return;
 6314|      0|  }
 6315|   554k|  SharedDtor();
 6316|   554k|}
_ZN11ruby_fuzzer9Statement16clear_stmt_oneofEv:
 6329|   395k|void Statement::clear_stmt_oneof() {
 6330|       |// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.Statement)
 6331|   395k|  switch (stmt_oneof_case()) {
  ------------------
  |  Branch (6331:11): [True: 0, False: 395k]
  ------------------
 6332|   215k|    case kAssignment: {
  ------------------
  |  Branch (6332:5): [True: 215k, False: 180k]
  ------------------
 6333|   215k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6333:11): [True: 215k, False: 0]
  ------------------
 6334|   215k|        delete _impl_.stmt_oneof_.assignment_;
 6335|   215k|      }
 6336|   215k|      break;
 6337|      0|    }
 6338|  17.5k|    case kIfelse: {
  ------------------
  |  Branch (6338:5): [True: 17.5k, False: 377k]
  ------------------
 6339|  17.5k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6339:11): [True: 17.5k, False: 0]
  ------------------
 6340|  17.5k|        delete _impl_.stmt_oneof_.ifelse_;
 6341|  17.5k|      }
 6342|  17.5k|      break;
 6343|      0|    }
 6344|  8.65k|    case kTernaryStmt: {
  ------------------
  |  Branch (6344:5): [True: 8.65k, False: 386k]
  ------------------
 6345|  8.65k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6345:11): [True: 8.65k, False: 0]
  ------------------
 6346|  8.65k|        delete _impl_.stmt_oneof_.ternary_stmt_;
 6347|  8.65k|      }
 6348|  8.65k|      break;
 6349|      0|    }
 6350|   119k|    case kBuiltins: {
  ------------------
  |  Branch (6350:5): [True: 119k, False: 275k]
  ------------------
 6351|   119k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6351:11): [True: 119k, False: 0]
  ------------------
 6352|   119k|        delete _impl_.stmt_oneof_.builtins_;
 6353|   119k|      }
 6354|   119k|      break;
 6355|      0|    }
 6356|  33.2k|    case kBlockstmt: {
  ------------------
  |  Branch (6356:5): [True: 33.2k, False: 362k]
  ------------------
 6357|  33.2k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6357:11): [True: 33.2k, False: 0]
  ------------------
 6358|  33.2k|        delete _impl_.stmt_oneof_.blockstmt_;
 6359|  33.2k|      }
 6360|  33.2k|      break;
 6361|      0|    }
 6362|  1.09k|    case STMT_ONEOF_NOT_SET: {
  ------------------
  |  Branch (6362:5): [True: 1.09k, False: 394k]
  ------------------
 6363|  1.09k|      break;
 6364|      0|    }
 6365|   395k|  }
 6366|   395k|  _impl_._oneof_case_[0] = STMT_ONEOF_NOT_SET;
 6367|   395k|}
_ZN11ruby_fuzzer9Statement5ClearEv:
 6370|  3.27k|void Statement::Clear() {
 6371|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Statement)
 6372|  3.27k|  ::uint32_t cached_has_bits = 0;
 6373|       |  // Prevent compiler warnings about cached_has_bits being unused
 6374|  3.27k|  (void) cached_has_bits;
 6375|       |
 6376|  3.27k|  clear_stmt_oneof();
 6377|  3.27k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 6378|  3.27k|}
_ZNK11ruby_fuzzer9Statement11GetMetadataEv:
 6653|  4.48M|::PROTOBUF_NAMESPACE_ID::Metadata Statement::GetMetadata() const {
 6654|  4.48M|  return ::_pbi::AssignDescriptors(
 6655|  4.48M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 6656|  4.48M|      file_level_metadata_ruby_2eproto[18]);
 6657|  4.48M|}
_ZN11ruby_fuzzer12StatementSeqC2EPN6google8protobuf5ArenaE:
 6665|  70.0k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 6666|  70.0k|  SharedCtor(arena);
 6667|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.StatementSeq)
 6668|  70.0k|}
_ZN11ruby_fuzzer12StatementSeqD2Ev:
 6688|  70.0k|StatementSeq::~StatementSeq() {
 6689|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.StatementSeq)
 6690|  70.0k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (6690:13): [True: 0, False: 70.0k]
  ------------------
 6691|      0|  (void)arena;
 6692|      0|    return;
 6693|      0|  }
 6694|  70.0k|  SharedDtor();
 6695|  70.0k|}
_ZN11ruby_fuzzer12StatementSeq5ClearEv:
 6706|     24|void StatementSeq::Clear() {
 6707|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.StatementSeq)
 6708|     24|  ::uint32_t cached_has_bits = 0;
 6709|       |  // Prevent compiler warnings about cached_has_bits being unused
 6710|     24|  (void) cached_has_bits;
 6711|       |
 6712|     24|  _impl_.statements_.Clear();
 6713|     24|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 6714|     24|}
_ZNK11ruby_fuzzer12StatementSeq12GetClassDataEv:
 6803|     12|const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StatementSeq::GetClassData() const { return &_class_data_; }
_ZN11ruby_fuzzer12StatementSeq9MergeImplERN6google8protobuf7MessageERKS3_:
 6806|      4|void StatementSeq::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
 6807|      4|  auto* const _this = static_cast<StatementSeq*>(&to_msg);
 6808|      4|  auto& from = static_cast<const StatementSeq&>(from_msg);
 6809|       |  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.StatementSeq)
 6810|      4|  ABSL_DCHECK_NE(&from, _this);
  ------------------
  |  |   72|      4|  ABSL_DCHECK_NE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   88|      4|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      4|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (56:10): [Folded - Ignored]
  |  |  |  |  |  |  |  Branch (56:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      4|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6811|      4|  ::uint32_t cached_has_bits = 0;
 6812|      4|  (void) cached_has_bits;
 6813|       |
 6814|      4|  _this->_impl_.statements_.MergeFrom(from._impl_.statements_);
 6815|      4|  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 6816|      4|}
_ZNK11ruby_fuzzer12StatementSeq11GetMetadataEv:
 6837|  2.08M|::PROTOBUF_NAMESPACE_ID::Metadata StatementSeq::GetMetadata() const {
 6838|  2.08M|  return ::_pbi::AssignDescriptors(
 6839|  2.08M|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 6840|  2.08M|      file_level_metadata_ruby_2eproto[19]);
 6841|  2.08M|}
_ZN11ruby_fuzzer8FunctionC2EPN6google8protobuf5ArenaE:
 6863|  1.76k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
 6864|  1.76k|  SharedCtor(arena);
 6865|       |  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Function)
 6866|  1.76k|}
_ZN11ruby_fuzzer8FunctionD2Ev:
 6891|  1.76k|Function::~Function() {
 6892|       |  // @@protoc_insertion_point(destructor:ruby_fuzzer.Function)
 6893|  1.76k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (6893:13): [True: 0, False: 1.76k]
  ------------------
 6894|      0|  (void)arena;
 6895|      0|    return;
 6896|      0|  }
 6897|  1.76k|  SharedDtor();
 6898|  1.76k|}
_ZN11ruby_fuzzer8Function5ClearEv:
 6909|  3.53k|void Function::Clear() {
 6910|       |// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Function)
 6911|  3.53k|  ::uint32_t cached_has_bits = 0;
 6912|       |  // Prevent compiler warnings about cached_has_bits being unused
 6913|  3.53k|  (void) cached_has_bits;
 6914|       |
 6915|  3.53k|  cached_has_bits = _impl_._has_bits_[0];
 6916|  3.53k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (6916:7): [True: 16, False: 3.52k]
  ------------------
 6917|     16|    ABSL_DCHECK(_impl_.statements_ != nullptr);
  ------------------
  |  |   43|     16|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|     16|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|     16|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|     16|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|     16|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|     16|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6918|     16|    _impl_.statements_->Clear();
 6919|     16|  }
 6920|  3.53k|  _impl_._has_bits_.Clear();
 6921|  3.53k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 6922|  3.53k|}
_ZNK11ruby_fuzzer8Function11GetMetadataEv:
 7047|  17.5k|::PROTOBUF_NAMESPACE_ID::Metadata Function::GetMetadata() const {
 7048|  17.5k|  return ::_pbi::AssignDescriptors(
 7049|  17.5k|      &descriptor_table_ruby_2eproto_getter, &descriptor_table_ruby_2eproto_once,
 7050|  17.5k|      file_level_metadata_ruby_2eproto[20]);
 7051|  17.5k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer6VarRefEJEEEPT_PS1_DpOT0_:
 7056|  73.2k|Arena::CreateMaybeMessage< ::ruby_fuzzer::VarRef >(Arena* arena) {
 7057|  73.2k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::VarRef >(arena);
 7058|  73.2k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer7ArrTypeEJEEEPT_PS1_DpOT0_:
 7060|  58.5k|Arena::CreateMaybeMessage< ::ruby_fuzzer::ArrType >(Arena* arena) {
 7061|  58.5k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::ArrType >(arena);
 7062|  58.5k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer6KVPairEJEEEPT_PS1_DpOT0_:
 7064|   129k|Arena::CreateMaybeMessage< ::ruby_fuzzer::KVPair >(Arena* arena) {
 7065|   129k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::KVPair >(arena);
 7066|   129k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer8HashTypeEJEEEPT_PS1_DpOT0_:
 7068|  20.6k|Arena::CreateMaybeMessage< ::ruby_fuzzer::HashType >(Arena* arena) {
 7069|  20.6k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::HashType >(arena);
 7070|  20.6k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer9MathConstEJEEEPT_PS1_DpOT0_:
 7076|  3.09k|Arena::CreateMaybeMessage< ::ruby_fuzzer::MathConst >(Arena* arena) {
 7077|  3.09k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::MathConst >(arena);
 7078|  3.09k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer5ConstEJEEEPT_PS1_DpOT0_:
 7080|   291k|Arena::CreateMaybeMessage< ::ruby_fuzzer::Const >(Arena* arena) {
 7081|   291k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::Const >(arena);
 7082|   291k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer8BinaryOpEJEEEPT_PS1_DpOT0_:
 7084|   131k|Arena::CreateMaybeMessage< ::ruby_fuzzer::BinaryOp >(Arena* arena) {
 7085|   131k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::BinaryOp >(arena);
 7086|   131k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer6RvalueEJEEEPT_PS1_DpOT0_:
 7088|   580k|Arena::CreateMaybeMessage< ::ruby_fuzzer::Rvalue >(Arena* arena) {
 7089|   580k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::Rvalue >(arena);
 7090|   580k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer19AssignmentStatementEJEEEPT_PS1_DpOT0_:
 7092|   215k|Arena::CreateMaybeMessage< ::ruby_fuzzer::AssignmentStatement >(Arena* arena) {
 7093|   215k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::AssignmentStatement >(arena);
 7094|   215k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer6IfElseEJEEEPT_PS1_DpOT0_:
 7096|  17.5k|Arena::CreateMaybeMessage< ::ruby_fuzzer::IfElse >(Arena* arena) {
 7097|  17.5k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::IfElse >(arena);
 7098|  17.5k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer7TernaryEJEEEPT_PS1_DpOT0_:
 7100|  8.65k|Arena::CreateMaybeMessage< ::ruby_fuzzer::Ternary >(Arena* arena) {
 7101|  8.65k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::Ternary >(arena);
 7102|  8.65k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer11ObjectSpaceEJEEEPT_PS1_DpOT0_:
 7104|  20.6k|Arena::CreateMaybeMessage< ::ruby_fuzzer::ObjectSpace >(Arena* arena) {
 7105|  20.6k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::ObjectSpace >(arena);
 7106|  20.6k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer4TimeEJEEEPT_PS1_DpOT0_:
 7108|  10.2k|Arena::CreateMaybeMessage< ::ruby_fuzzer::Time >(Arena* arena) {
 7109|  10.2k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::Time >(arena);
 7110|  10.2k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer5ArrayEJEEEPT_PS1_DpOT0_:
 7112|  56.1k|Arena::CreateMaybeMessage< ::ruby_fuzzer::Array >(Arena* arena) {
 7113|  56.1k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::Array >(arena);
 7114|  56.1k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer8MathTypeEJEEEPT_PS1_DpOT0_:
 7116|  9.45k|Arena::CreateMaybeMessage< ::ruby_fuzzer::MathType >(Arena* arena) {
 7117|  9.45k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::MathType >(arena);
 7118|  9.45k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer7MathOpsEJEEEPT_PS1_DpOT0_:
 7120|  9.47k|Arena::CreateMaybeMessage< ::ruby_fuzzer::MathOps >(Arena* arena) {
 7121|  9.47k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::MathOps >(arena);
 7122|  9.47k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer12BuiltinFuncsEJEEEPT_PS1_DpOT0_:
 7124|   119k|Arena::CreateMaybeMessage< ::ruby_fuzzer::BuiltinFuncs >(Arena* arena) {
 7125|   119k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::BuiltinFuncs >(arena);
 7126|   119k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer9StatementEJEEEPT_PS1_DpOT0_:
 7128|   554k|Arena::CreateMaybeMessage< ::ruby_fuzzer::Statement >(Arena* arena) {
 7129|   554k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::Statement >(arena);
 7130|   554k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN11ruby_fuzzer12StatementSeqEJEEEPT_PS1_DpOT0_:
 7132|  70.0k|Arena::CreateMaybeMessage< ::ruby_fuzzer::StatementSeq >(Arena* arena) {
 7133|  70.0k|  return Arena::CreateMessageInternal< ::ruby_fuzzer::StatementSeq >(arena);
 7134|  70.0k|}
_ZN11ruby_fuzzer6VarRef10SharedCtorEPN6google8protobuf5ArenaE:
 1060|  73.2k|inline void VarRef::SharedCtor(::_pb::Arena* arena) {
 1061|  73.2k|  (void)arena;
 1062|  73.2k|  new (&_impl_) Impl_{
 1063|  73.2k|      decltype(_impl_._has_bits_){}
 1064|  73.2k|    , /*decltype(_impl_._cached_size_)*/{}
 1065|  73.2k|    , decltype(_impl_.varnum_) { 0 }
 1066|       |
 1067|  73.2k|  };
 1068|  73.2k|}
_ZN11ruby_fuzzer6VarRef10SharedDtorEv:
 1079|  73.2k|inline void VarRef::SharedDtor() {
 1080|  73.2k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  73.2k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  73.2k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  73.2k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  73.2k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  73.2k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  73.2k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1081|  73.2k|}
_ZN11ruby_fuzzer7ArrType10SharedCtorEPN6google8protobuf5ArenaE:
 1245|  58.5k|inline void ArrType::SharedCtor(::_pb::Arena* arena) {
 1246|  58.5k|  (void)arena;
 1247|  58.5k|  new (&_impl_) Impl_{
 1248|  58.5k|      decltype(_impl_.elements_){arena}
 1249|  58.5k|    , /*decltype(_impl_._cached_size_)*/{}
 1250|  58.5k|  };
 1251|  58.5k|}
_ZN11ruby_fuzzer7ArrType10SharedDtorEv:
 1262|  58.5k|inline void ArrType::SharedDtor() {
 1263|  58.5k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  58.5k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  58.5k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  58.5k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  58.5k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  58.5k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  58.5k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1264|  58.5k|  _impl_.elements_.~RepeatedPtrField();
 1265|  58.5k|}
_ZN11ruby_fuzzer6KVPair10SharedCtorEPN6google8protobuf5ArenaE:
 1457|   129k|inline void KVPair::SharedCtor(::_pb::Arena* arena) {
 1458|   129k|  (void)arena;
 1459|   129k|  new (&_impl_) Impl_{
 1460|   129k|      decltype(_impl_._has_bits_){}
 1461|   129k|    , /*decltype(_impl_._cached_size_)*/{}
 1462|   129k|    , decltype(_impl_.key_) {}
 1463|       |
 1464|   129k|    , decltype(_impl_.val_) {}
 1465|       |
 1466|   129k|  };
 1467|   129k|  _impl_.key_.InitDefault();
 1468|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1469|       |        _impl_.key_.Set("", GetArenaForAllocation());
 1470|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1471|   129k|  _impl_.val_.InitDefault();
 1472|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1473|       |        _impl_.val_.Set("", GetArenaForAllocation());
 1474|       |  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1475|   129k|}
_ZN11ruby_fuzzer6KVPair10SharedDtorEv:
 1486|   129k|inline void KVPair::SharedDtor() {
 1487|   129k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   129k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   129k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   129k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   129k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   129k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   129k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1488|   129k|  _impl_.key_.Destroy();
 1489|   129k|  _impl_.val_.Destroy();
 1490|   129k|}
_ZN11ruby_fuzzer8HashType10SharedCtorEPN6google8protobuf5ArenaE:
 1722|  20.6k|inline void HashType::SharedCtor(::_pb::Arena* arena) {
 1723|  20.6k|  (void)arena;
 1724|  20.6k|  new (&_impl_) Impl_{
 1725|  20.6k|      decltype(_impl_.keyval_){arena}
 1726|  20.6k|    , /*decltype(_impl_._cached_size_)*/{}
 1727|  20.6k|  };
 1728|  20.6k|}
_ZN11ruby_fuzzer8HashType10SharedDtorEv:
 1739|  20.6k|inline void HashType::SharedDtor() {
 1740|  20.6k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  20.6k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  20.6k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  20.6k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  20.6k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  20.6k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  20.6k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1741|  20.6k|  _impl_.keyval_.~RepeatedPtrField();
 1742|  20.6k|}
_ZN11ruby_fuzzer9MathConst10SharedCtorEPN6google8protobuf5ArenaE:
 2191|  3.09k|inline void MathConst::SharedCtor(::_pb::Arena* arena) {
 2192|  3.09k|  (void)arena;
 2193|  3.09k|  new (&_impl_) Impl_{
 2194|  3.09k|      decltype(_impl_._has_bits_){}
 2195|  3.09k|    , /*decltype(_impl_._cached_size_)*/{}
 2196|  3.09k|    , decltype(_impl_.math_const_) { 0 }
 2197|       |
 2198|  3.09k|  };
 2199|  3.09k|}
_ZN11ruby_fuzzer9MathConst10SharedDtorEv:
 2210|  3.09k|inline void MathConst::SharedDtor() {
 2211|  3.09k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  3.09k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  3.09k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  3.09k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  3.09k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  3.09k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  3.09k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2212|  3.09k|}
_ZN11ruby_fuzzer5Const10SharedCtorEPN6google8protobuf5ArenaE:
 2396|   291k|inline void Const::SharedCtor(::_pb::Arena* arena) {
 2397|   291k|  (void)arena;
 2398|   291k|  new (&_impl_) Impl_{
 2399|   291k|      decltype(_impl_.const_oneof_){}
 2400|   291k|    , /*decltype(_impl_._cached_size_)*/{}
 2401|   291k|    , /*decltype(_impl_._oneof_case_)*/{}
 2402|   291k|  };
 2403|   291k|  clear_has_const_oneof();
 2404|   291k|}
_ZN11ruby_fuzzer5Const10SharedDtorEv:
 2415|   291k|inline void Const::SharedDtor() {
 2416|   291k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   291k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   291k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   291k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   291k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   291k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   291k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2417|   291k|  if (has_const_oneof()) {
  ------------------
  |  Branch (2417:7): [True: 44.7k, False: 246k]
  ------------------
 2418|  44.7k|    clear_const_oneof();
 2419|  44.7k|  }
 2420|   291k|}
_ZN11ruby_fuzzer8BinaryOp10SharedCtorEPN6google8protobuf5ArenaE:
 2670|   131k|inline void BinaryOp::SharedCtor(::_pb::Arena* arena) {
 2671|   131k|  (void)arena;
 2672|   131k|  new (&_impl_) Impl_{
 2673|   131k|      decltype(_impl_._has_bits_){}
 2674|   131k|    , /*decltype(_impl_._cached_size_)*/{}
 2675|   131k|    , decltype(_impl_.left_){nullptr}
 2676|   131k|    , decltype(_impl_.right_){nullptr}
 2677|   131k|    , decltype(_impl_.op_) { 0 }
 2678|       |
 2679|   131k|  };
 2680|   131k|}
_ZN11ruby_fuzzer8BinaryOp10SharedDtorEv:
 2691|   131k|inline void BinaryOp::SharedDtor() {
 2692|   131k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   131k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   131k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   131k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   131k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   131k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   131k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2693|   131k|  if (this != internal_default_instance()) delete _impl_.left_;
  ------------------
  |  Branch (2693:7): [True: 131k, False: 0]
  ------------------
 2694|   131k|  if (this != internal_default_instance()) delete _impl_.right_;
  ------------------
  |  Branch (2694:7): [True: 131k, False: 0]
  ------------------
 2695|   131k|}
_ZN11ruby_fuzzer6Rvalue10SharedCtorEPN6google8protobuf5ArenaE:
 3051|   580k|inline void Rvalue::SharedCtor(::_pb::Arena* arena) {
 3052|   580k|  (void)arena;
 3053|   580k|  new (&_impl_) Impl_{
 3054|   580k|      decltype(_impl_.rvalue_oneof_){}
 3055|   580k|    , /*decltype(_impl_._cached_size_)*/{}
 3056|   580k|    , /*decltype(_impl_._oneof_case_)*/{}
 3057|   580k|  };
 3058|   580k|  clear_has_rvalue_oneof();
 3059|   580k|}
_ZN11ruby_fuzzer6Rvalue10SharedDtorEv:
 3070|   580k|inline void Rvalue::SharedDtor() {
 3071|   580k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   580k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   580k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   580k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   580k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   580k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   580k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3072|   580k|  if (has_rvalue_oneof()) {
  ------------------
  |  Branch (3072:7): [True: 242k, False: 338k]
  ------------------
 3073|   242k|    clear_rvalue_oneof();
 3074|   242k|  }
 3075|   580k|}
_ZN11ruby_fuzzer19AssignmentStatement10SharedCtorEPN6google8protobuf5ArenaE:
 3369|   215k|inline void AssignmentStatement::SharedCtor(::_pb::Arena* arena) {
 3370|   215k|  (void)arena;
 3371|   215k|  new (&_impl_) Impl_{
 3372|   215k|      decltype(_impl_._has_bits_){}
 3373|   215k|    , /*decltype(_impl_._cached_size_)*/{}
 3374|   215k|    , decltype(_impl_.rvalue_){nullptr}
 3375|   215k|  };
 3376|   215k|}
_ZN11ruby_fuzzer19AssignmentStatement10SharedDtorEv:
 3387|   215k|inline void AssignmentStatement::SharedDtor() {
 3388|   215k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   215k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   215k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   215k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   215k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   215k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   215k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3389|   215k|  if (this != internal_default_instance()) delete _impl_.rvalue_;
  ------------------
  |  Branch (3389:7): [True: 215k, False: 0]
  ------------------
 3390|   215k|}
_ZN11ruby_fuzzer6IfElse10SharedCtorEPN6google8protobuf5ArenaE:
 3603|  17.5k|inline void IfElse::SharedCtor(::_pb::Arena* arena) {
 3604|  17.5k|  (void)arena;
 3605|  17.5k|  new (&_impl_) Impl_{
 3606|  17.5k|      decltype(_impl_._has_bits_){}
 3607|  17.5k|    , /*decltype(_impl_._cached_size_)*/{}
 3608|  17.5k|    , decltype(_impl_.cond_){nullptr}
 3609|  17.5k|    , decltype(_impl_.if_body_){nullptr}
 3610|  17.5k|    , decltype(_impl_.else_body_){nullptr}
 3611|  17.5k|  };
 3612|  17.5k|}
_ZN11ruby_fuzzer6IfElse10SharedDtorEv:
 3623|  17.5k|inline void IfElse::SharedDtor() {
 3624|  17.5k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  17.5k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  17.5k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  17.5k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  17.5k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  17.5k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  17.5k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3625|  17.5k|  if (this != internal_default_instance()) delete _impl_.cond_;
  ------------------
  |  Branch (3625:7): [True: 17.5k, False: 0]
  ------------------
 3626|  17.5k|  if (this != internal_default_instance()) delete _impl_.if_body_;
  ------------------
  |  Branch (3626:7): [True: 17.5k, False: 0]
  ------------------
 3627|  17.5k|  if (this != internal_default_instance()) delete _impl_.else_body_;
  ------------------
  |  Branch (3627:7): [True: 17.5k, False: 0]
  ------------------
 3628|  17.5k|}
_ZN11ruby_fuzzer7Ternary10SharedCtorEPN6google8protobuf5ArenaE:
 3945|  8.65k|inline void Ternary::SharedCtor(::_pb::Arena* arena) {
 3946|  8.65k|  (void)arena;
 3947|  8.65k|  new (&_impl_) Impl_{
 3948|  8.65k|      decltype(_impl_._has_bits_){}
 3949|  8.65k|    , /*decltype(_impl_._cached_size_)*/{}
 3950|  8.65k|    , decltype(_impl_.tern_cond_){nullptr}
 3951|  8.65k|    , decltype(_impl_.t_branch_){nullptr}
 3952|  8.65k|    , decltype(_impl_.f_branch_){nullptr}
 3953|  8.65k|  };
 3954|  8.65k|}
_ZN11ruby_fuzzer7Ternary10SharedDtorEv:
 3965|  8.65k|inline void Ternary::SharedDtor() {
 3966|  8.65k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  8.65k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  8.65k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  8.65k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  8.65k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  8.65k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  8.65k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3967|  8.65k|  if (this != internal_default_instance()) delete _impl_.tern_cond_;
  ------------------
  |  Branch (3967:7): [True: 8.65k, False: 0]
  ------------------
 3968|  8.65k|  if (this != internal_default_instance()) delete _impl_.t_branch_;
  ------------------
  |  Branch (3968:7): [True: 8.65k, False: 0]
  ------------------
 3969|  8.65k|  if (this != internal_default_instance()) delete _impl_.f_branch_;
  ------------------
  |  Branch (3969:7): [True: 8.65k, False: 0]
  ------------------
 3970|  8.65k|}
_ZN11ruby_fuzzer11ObjectSpace10SharedCtorEPN6google8protobuf5ArenaE:
 4269|  20.6k|inline void ObjectSpace::SharedCtor(::_pb::Arena* arena) {
 4270|  20.6k|  (void)arena;
 4271|  20.6k|  new (&_impl_) Impl_{
 4272|  20.6k|      decltype(_impl_._has_bits_){}
 4273|  20.6k|    , /*decltype(_impl_._cached_size_)*/{}
 4274|  20.6k|    , decltype(_impl_.os_arg_){nullptr}
 4275|  20.6k|    , decltype(_impl_.os_func_) { 1 }
 4276|       |
 4277|  20.6k|  };
 4278|  20.6k|}
_ZN11ruby_fuzzer11ObjectSpace10SharedDtorEv:
 4289|  20.6k|inline void ObjectSpace::SharedDtor() {
 4290|  20.6k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  20.6k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  20.6k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  20.6k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  20.6k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  20.6k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  20.6k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4291|  20.6k|  if (this != internal_default_instance()) delete _impl_.os_arg_;
  ------------------
  |  Branch (4291:7): [True: 20.6k, False: 0]
  ------------------
 4292|  20.6k|}
_ZN11ruby_fuzzer4Time10SharedCtorEPN6google8protobuf5ArenaE:
 4533|  10.2k|inline void Time::SharedCtor(::_pb::Arena* arena) {
 4534|  10.2k|  (void)arena;
 4535|  10.2k|  new (&_impl_) Impl_{
 4536|  10.2k|      decltype(_impl_._has_bits_){}
 4537|  10.2k|    , /*decltype(_impl_._cached_size_)*/{}
 4538|  10.2k|    , decltype(_impl_.t_arg_) { 0u }
 4539|       |
 4540|  10.2k|    , decltype(_impl_.t_func_) { 1 }
 4541|       |
 4542|  10.2k|  };
 4543|  10.2k|}
_ZN11ruby_fuzzer4Time10SharedDtorEv:
 4554|  10.2k|inline void Time::SharedDtor() {
 4555|  10.2k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  10.2k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  10.2k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  10.2k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  10.2k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  10.2k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  10.2k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4556|  10.2k|}
_ZN11ruby_fuzzer5Array10SharedCtorEPN6google8protobuf5ArenaE:
 4817|  56.1k|inline void Array::SharedCtor(::_pb::Arena* arena) {
 4818|  56.1k|  (void)arena;
 4819|  56.1k|  new (&_impl_) Impl_{
 4820|  56.1k|      decltype(_impl_._has_bits_){}
 4821|  56.1k|    , /*decltype(_impl_._cached_size_)*/{}
 4822|  56.1k|    , decltype(_impl_.arr_arg_){nullptr}
 4823|  56.1k|    , decltype(_impl_.val_arg_){nullptr}
 4824|  56.1k|    , decltype(_impl_.arr_func_) { 1 }
 4825|       |
 4826|  56.1k|  };
 4827|  56.1k|}
_ZN11ruby_fuzzer5Array10SharedDtorEv:
 4838|  56.1k|inline void Array::SharedDtor() {
 4839|  56.1k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  56.1k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  56.1k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  56.1k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  56.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  56.1k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  56.1k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4840|  56.1k|  if (this != internal_default_instance()) delete _impl_.arr_arg_;
  ------------------
  |  Branch (4840:7): [True: 56.1k, False: 0]
  ------------------
 4841|  56.1k|  if (this != internal_default_instance()) delete _impl_.val_arg_;
  ------------------
  |  Branch (4841:7): [True: 56.1k, False: 0]
  ------------------
 4842|  56.1k|}
_ZN11ruby_fuzzer8MathType10SharedCtorEPN6google8protobuf5ArenaE:
 5170|  9.45k|inline void MathType::SharedCtor(::_pb::Arena* arena) {
 5171|  9.45k|  (void)arena;
 5172|  9.45k|  new (&_impl_) Impl_{
 5173|  9.45k|      decltype(_impl_.math_arg_oneof_){}
 5174|  9.45k|    , /*decltype(_impl_._cached_size_)*/{}
 5175|  9.45k|    , /*decltype(_impl_._oneof_case_)*/{}
 5176|  9.45k|  };
 5177|  9.45k|  clear_has_math_arg_oneof();
 5178|  9.45k|}
_ZN11ruby_fuzzer8MathType10SharedDtorEv:
 5189|  9.45k|inline void MathType::SharedDtor() {
 5190|  9.45k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  9.45k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  9.45k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  9.45k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  9.45k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  9.45k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  9.45k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5191|  9.45k|  if (has_math_arg_oneof()) {
  ------------------
  |  Branch (5191:7): [True: 4.49k, False: 4.95k]
  ------------------
 5192|  4.49k|    clear_math_arg_oneof();
 5193|  4.49k|  }
 5194|  9.45k|}
_ZN11ruby_fuzzer7MathOps10SharedCtorEPN6google8protobuf5ArenaE:
 5458|  9.47k|inline void MathOps::SharedCtor(::_pb::Arena* arena) {
 5459|  9.47k|  (void)arena;
 5460|  9.47k|  new (&_impl_) Impl_{
 5461|  9.47k|      decltype(_impl_._has_bits_){}
 5462|  9.47k|    , /*decltype(_impl_._cached_size_)*/{}
 5463|  9.47k|    , decltype(_impl_.math_arg_){nullptr}
 5464|  9.47k|    , decltype(_impl_.math_op_) { 1 }
 5465|       |
 5466|  9.47k|  };
 5467|  9.47k|}
_ZN11ruby_fuzzer7MathOps10SharedDtorEv:
 5478|  9.47k|inline void MathOps::SharedDtor() {
 5479|  9.47k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  9.47k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  9.47k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  9.47k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  9.47k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  9.47k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  9.47k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5480|  9.47k|  if (this != internal_default_instance()) delete _impl_.math_arg_;
  ------------------
  |  Branch (5480:7): [True: 9.47k, False: 0]
  ------------------
 5481|  9.47k|}
_ZN11ruby_fuzzer12BuiltinFuncs10SharedCtorEPN6google8protobuf5ArenaE:
 5823|   119k|inline void BuiltinFuncs::SharedCtor(::_pb::Arena* arena) {
 5824|   119k|  (void)arena;
 5825|   119k|  new (&_impl_) Impl_{
 5826|   119k|      decltype(_impl_.bifunc_oneof_){}
 5827|   119k|    , /*decltype(_impl_._cached_size_)*/{}
 5828|   119k|    , /*decltype(_impl_._oneof_case_)*/{}
 5829|   119k|  };
 5830|   119k|  clear_has_bifunc_oneof();
 5831|   119k|}
_ZN11ruby_fuzzer12BuiltinFuncs10SharedDtorEv:
 5842|   119k|inline void BuiltinFuncs::SharedDtor() {
 5843|   119k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   119k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   119k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   119k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   119k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   119k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   119k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5844|   119k|  if (has_bifunc_oneof()) {
  ------------------
  |  Branch (5844:7): [True: 96.5k, False: 23.1k]
  ------------------
 5845|  96.5k|    clear_bifunc_oneof();
 5846|  96.5k|  }
 5847|   119k|}
_ZN11ruby_fuzzer9Statement10SharedCtorEPN6google8protobuf5ArenaE:
 6299|   554k|inline void Statement::SharedCtor(::_pb::Arena* arena) {
 6300|   554k|  (void)arena;
 6301|   554k|  new (&_impl_) Impl_{
 6302|   554k|      decltype(_impl_.stmt_oneof_){}
 6303|   554k|    , /*decltype(_impl_._cached_size_)*/{}
 6304|   554k|    , /*decltype(_impl_._oneof_case_)*/{}
 6305|   554k|  };
 6306|   554k|  clear_has_stmt_oneof();
 6307|   554k|}
_ZN11ruby_fuzzer9Statement10SharedDtorEv:
 6318|   554k|inline void Statement::SharedDtor() {
 6319|   554k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|   554k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|   554k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|   554k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|   554k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|   554k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|   554k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6320|   554k|  if (has_stmt_oneof()) {
  ------------------
  |  Branch (6320:7): [True: 391k, False: 162k]
  ------------------
 6321|   391k|    clear_stmt_oneof();
 6322|   391k|  }
 6323|   554k|}
_ZN11ruby_fuzzer12StatementSeq10SharedCtorEPN6google8protobuf5ArenaE:
 6680|  70.0k|inline void StatementSeq::SharedCtor(::_pb::Arena* arena) {
 6681|  70.0k|  (void)arena;
 6682|  70.0k|  new (&_impl_) Impl_{
 6683|  70.0k|      decltype(_impl_.statements_){arena}
 6684|  70.0k|    , /*decltype(_impl_._cached_size_)*/{}
 6685|  70.0k|  };
 6686|  70.0k|}
_ZN11ruby_fuzzer12StatementSeq10SharedDtorEv:
 6697|  70.0k|inline void StatementSeq::SharedDtor() {
 6698|  70.0k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  70.0k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  70.0k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  70.0k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  70.0k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  70.0k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  70.0k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6699|  70.0k|  _impl_.statements_.~RepeatedPtrField();
 6700|  70.0k|}
_ZN11ruby_fuzzer8Function10SharedCtorEPN6google8protobuf5ArenaE:
 6882|  1.76k|inline void Function::SharedCtor(::_pb::Arena* arena) {
 6883|  1.76k|  (void)arena;
 6884|  1.76k|  new (&_impl_) Impl_{
 6885|  1.76k|      decltype(_impl_._has_bits_){}
 6886|  1.76k|    , /*decltype(_impl_._cached_size_)*/{}
 6887|  1.76k|    , decltype(_impl_.statements_){nullptr}
 6888|  1.76k|  };
 6889|  1.76k|}
_ZN11ruby_fuzzer8Function10SharedDtorEv:
 6900|  1.76k|inline void Function::SharedDtor() {
 6901|  1.76k|  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |   43|  1.76k|#define ABSL_DCHECK(condition) ABSL_DCHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   43|  1.76k|  ABSL_CHECK_IMPL(true || (condition), "true")
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|  1.76k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  157|  1.76k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   27|  1.76k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   28|  1.76k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6902|  1.76k|  if (this != internal_default_instance()) delete _impl_.statements_;
  ------------------
  |  Branch (6902:7): [True: 1.76k, False: 0]
  ------------------
 6903|  1.76k|}

_ZN11ruby_fuzzer8FunctionC2Ev:
 4346|  1.76k|  inline Function() : Function(nullptr) {}
_ZNK11ruby_fuzzer6VarRef3NewEPN6google8protobuf5ArenaE:
  493|  73.2k|  VarRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  494|  73.2k|    return CreateMaybeMessage<VarRef>(arena);
  495|  73.2k|  }
_ZNK11ruby_fuzzer7ArrType3NewEPN6google8protobuf5ArenaE:
  649|  58.5k|  ArrType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  650|  58.5k|    return CreateMaybeMessage<ArrType>(arena);
  651|  58.5k|  }
_ZNK11ruby_fuzzer6KVPair3NewEPN6google8protobuf5ArenaE:
  811|   129k|  KVPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  812|   129k|    return CreateMaybeMessage<KVPair>(arena);
  813|   129k|  }
_ZNK11ruby_fuzzer8HashType3NewEPN6google8protobuf5ArenaE:
 1003|  20.6k|  HashType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1004|  20.6k|    return CreateMaybeMessage<HashType>(arena);
 1005|  20.6k|  }
_ZNK11ruby_fuzzer9MathConst3NewEPN6google8protobuf5ArenaE:
 1375|  3.09k|  MathConst* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1376|  3.09k|    return CreateMaybeMessage<MathConst>(arena);
 1377|  3.09k|  }
_ZNK11ruby_fuzzer5Const3NewEPN6google8protobuf5ArenaE:
 1557|   291k|  Const* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1558|   291k|    return CreateMaybeMessage<Const>(arena);
 1559|   291k|  }
_ZN11ruby_fuzzer5Const5Impl_15ConstOneofUnionC2Ev:
 1644|   291k|      constexpr ConstOneofUnion() : _constinit_{} {}
_ZN11ruby_fuzzer8BinaryOp25internal_default_instanceEv:
 1707|   262k|  static inline const BinaryOp* internal_default_instance() {
 1708|   262k|    return reinterpret_cast<const BinaryOp*>(
 1709|   262k|               &_BinaryOp_default_instance_);
 1710|   262k|  }
_ZNK11ruby_fuzzer8BinaryOp3NewEPN6google8protobuf5ArenaE:
 1738|   131k|  BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1739|   131k|    return CreateMaybeMessage<BinaryOp>(arena);
 1740|   131k|  }
_ZNK11ruby_fuzzer6Rvalue3NewEPN6google8protobuf5ArenaE:
 1969|   580k|  Rvalue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1970|   580k|    return CreateMaybeMessage<Rvalue>(arena);
 1971|   580k|  }
_ZN11ruby_fuzzer6Rvalue5Impl_16RvalueOneofUnionC2Ev:
 2090|   580k|      constexpr RvalueOneofUnion() : _constinit_{} {}
_ZN11ruby_fuzzer19AssignmentStatement25internal_default_instanceEv:
 2154|   215k|  static inline const AssignmentStatement* internal_default_instance() {
 2155|   215k|    return reinterpret_cast<const AssignmentStatement*>(
 2156|   215k|               &_AssignmentStatement_default_instance_);
 2157|   215k|  }
_ZNK11ruby_fuzzer19AssignmentStatement3NewEPN6google8protobuf5ArenaE:
 2185|   215k|  AssignmentStatement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2186|   215k|    return CreateMaybeMessage<AssignmentStatement>(arena);
 2187|   215k|  }
_ZN11ruby_fuzzer6IfElse25internal_default_instanceEv:
 2313|  52.5k|  static inline const IfElse* internal_default_instance() {
 2314|  52.5k|    return reinterpret_cast<const IfElse*>(
 2315|  52.5k|               &_IfElse_default_instance_);
 2316|  52.5k|  }
_ZNK11ruby_fuzzer6IfElse3NewEPN6google8protobuf5ArenaE:
 2344|  17.5k|  IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2345|  17.5k|    return CreateMaybeMessage<IfElse>(arena);
 2346|  17.5k|  }
_ZN11ruby_fuzzer7Ternary25internal_default_instanceEv:
 2507|  25.9k|  static inline const Ternary* internal_default_instance() {
 2508|  25.9k|    return reinterpret_cast<const Ternary*>(
 2509|  25.9k|               &_Ternary_default_instance_);
 2510|  25.9k|  }
_ZNK11ruby_fuzzer7Ternary3NewEPN6google8protobuf5ArenaE:
 2538|  8.65k|  Ternary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2539|  8.65k|    return CreateMaybeMessage<Ternary>(arena);
 2540|  8.65k|  }
_ZN11ruby_fuzzer11ObjectSpace25internal_default_instanceEv:
 2701|  20.6k|  static inline const ObjectSpace* internal_default_instance() {
 2702|  20.6k|    return reinterpret_cast<const ObjectSpace*>(
 2703|  20.6k|               &_ObjectSpace_default_instance_);
 2704|  20.6k|  }
_ZNK11ruby_fuzzer11ObjectSpace3NewEPN6google8protobuf5ArenaE:
 2732|  20.6k|  ObjectSpace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2733|  20.6k|    return CreateMaybeMessage<ObjectSpace>(arena);
 2734|  20.6k|  }
_ZNK11ruby_fuzzer4Time3NewEPN6google8protobuf5ArenaE:
 2926|  10.2k|  Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2927|  10.2k|    return CreateMaybeMessage<Time>(arena);
 2928|  10.2k|  }
_ZN11ruby_fuzzer5Array25internal_default_instanceEv:
 3087|   112k|  static inline const Array* internal_default_instance() {
 3088|   112k|    return reinterpret_cast<const Array*>(
 3089|   112k|               &_Array_default_instance_);
 3090|   112k|  }
_ZNK11ruby_fuzzer5Array3NewEPN6google8protobuf5ArenaE:
 3118|  56.1k|  Array* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3119|  56.1k|    return CreateMaybeMessage<Array>(arena);
 3120|  56.1k|  }
_ZNK11ruby_fuzzer8MathType3NewEPN6google8protobuf5ArenaE:
 3352|  9.45k|  MathType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3353|  9.45k|    return CreateMaybeMessage<MathType>(arena);
 3354|  9.45k|  }
_ZN11ruby_fuzzer8MathType5Impl_17MathArgOneofUnionC2Ev:
 3453|  9.45k|      constexpr MathArgOneofUnion() : _constinit_{} {}
_ZN11ruby_fuzzer7MathOps25internal_default_instanceEv:
 3516|  9.47k|  static inline const MathOps* internal_default_instance() {
 3517|  9.47k|    return reinterpret_cast<const MathOps*>(
 3518|  9.47k|               &_MathOps_default_instance_);
 3519|  9.47k|  }
_ZNK11ruby_fuzzer7MathOps3NewEPN6google8protobuf5ArenaE:
 3547|  9.47k|  MathOps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3548|  9.47k|    return CreateMaybeMessage<MathOps>(arena);
 3549|  9.47k|  }
_ZNK11ruby_fuzzer12BuiltinFuncs3NewEPN6google8protobuf5ArenaE:
 3758|   119k|  BuiltinFuncs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3759|   119k|    return CreateMaybeMessage<BuiltinFuncs>(arena);
 3760|   119k|  }
_ZN11ruby_fuzzer12BuiltinFuncs5Impl_16BifuncOneofUnionC2Ev:
 3899|   119k|      constexpr BifuncOneofUnion() : _constinit_{} {}
_ZNK11ruby_fuzzer9Statement3NewEPN6google8protobuf5ArenaE:
 4004|   554k|  Statement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4005|   554k|    return CreateMaybeMessage<Statement>(arena);
 4006|   554k|  }
_ZN11ruby_fuzzer9Statement5Impl_14StmtOneofUnionC2Ev:
 4165|   554k|      constexpr StmtOneofUnion() : _constinit_{} {}
_ZNK11ruby_fuzzer12StatementSeq3NewEPN6google8protobuf5ArenaE:
 4262|  70.0k|  StatementSeq* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4263|  70.0k|    return CreateMaybeMessage<StatementSeq>(arena);
 4264|  70.0k|  }
_ZN11ruby_fuzzer8Function25internal_default_instanceEv:
 4393|  1.76k|  static inline const Function* internal_default_instance() {
 4394|  1.76k|    return reinterpret_cast<const Function*>(
 4395|  1.76k|               &_Function_default_instance_);
 4396|  1.76k|  }
_ZNK11ruby_fuzzer6VarRef6varnumEv:
 4527|  72.8k|inline ::int32_t VarRef::varnum() const {
 4528|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.VarRef.varnum)
 4529|  72.8k|  return _internal_varnum();
 4530|  72.8k|}
_ZNK11ruby_fuzzer6VarRef16_internal_varnumEv:
 4535|  72.8k|inline ::int32_t VarRef::_internal_varnum() const {
 4536|  72.8k|  return _impl_.varnum_;
 4537|  72.8k|}
_ZNK11ruby_fuzzer7ArrType23_internal_elements_sizeEv:
 4548|  63.0k|inline int ArrType::_internal_elements_size() const {
 4549|  63.0k|  return _impl_.elements_.size();
 4550|  63.0k|}
_ZNK11ruby_fuzzer7ArrType13elements_sizeEv:
 4551|  63.0k|inline int ArrType::elements_size() const {
 4552|  63.0k|  return _internal_elements_size();
 4553|  63.0k|}
_ZNK11ruby_fuzzer7ArrType8elementsEv:
 4582|  7.26k|ArrType::elements() const {
 4583|       |  // @@protoc_insertion_point(field_list:ruby_fuzzer.ArrType.elements)
 4584|  7.26k|  return _impl_.elements_;
 4585|  7.26k|}
_ZNK11ruby_fuzzer6KVPair3keyEv:
 4600|   129k|inline const std::string& KVPair::key() const {
 4601|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.KVPair.key)
 4602|   129k|  return _internal_key();
 4603|   129k|}
_ZNK11ruby_fuzzer6KVPair13_internal_keyEv:
 4616|   129k|inline const std::string& KVPair::_internal_key() const {
 4617|   129k|  return _impl_.key_.Get();
 4618|   129k|}
_ZNK11ruby_fuzzer6KVPair3valEv:
 4665|   129k|inline const std::string& KVPair::val() const {
 4666|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.KVPair.val)
 4667|   129k|  return _internal_val();
 4668|   129k|}
_ZNK11ruby_fuzzer6KVPair13_internal_valEv:
 4681|   129k|inline const std::string& KVPair::_internal_val() const {
 4682|   129k|  return _impl_.val_.Get();
 4683|   129k|}
_ZNK11ruby_fuzzer8HashType21_internal_keyval_sizeEv:
 4726|  24.2k|inline int HashType::_internal_keyval_size() const {
 4727|  24.2k|  return _impl_.keyval_.size();
 4728|  24.2k|}
_ZNK11ruby_fuzzer8HashType11keyval_sizeEv:
 4729|  24.2k|inline int HashType::keyval_size() const {
 4730|  24.2k|  return _internal_keyval_size();
 4731|  24.2k|}
_ZNK11ruby_fuzzer8HashType6keyvalEv:
 4760|  3.61k|HashType::keyval() const {
 4761|       |  // @@protoc_insertion_point(field_list:ruby_fuzzer.HashType.keyval)
 4762|  3.61k|  return _impl_.keyval_;
 4763|  3.61k|}
_ZNK11ruby_fuzzer9MathConst10math_constEv:
 4873|  3.08k|inline ::ruby_fuzzer::MathConst_MathConstLit MathConst::math_const() const {
 4874|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathConst.math_const)
 4875|  3.08k|  return _internal_math_const();
 4876|  3.08k|}
_ZNK11ruby_fuzzer9MathConst20_internal_math_constEv:
 4881|  3.08k|inline ::ruby_fuzzer::MathConst_MathConstLit MathConst::_internal_math_const() const {
 4882|  3.08k|  return static_cast<::ruby_fuzzer::MathConst_MathConstLit>(_impl_.math_const_);
 4883|  3.08k|}
_ZNK11ruby_fuzzer5Const7int_litEv:
 4907|  32.2k|inline ::uint32_t Const::int_lit() const {
 4908|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Const.int_lit)
 4909|  32.2k|  return _internal_int_lit();
 4910|  32.2k|}
_ZNK11ruby_fuzzer5Const17_internal_int_litEv:
 4915|  32.2k|inline ::uint32_t Const::_internal_int_lit() const {
 4916|  32.2k|  if (const_oneof_case() == kIntLit) {
  ------------------
  |  Branch (4916:7): [True: 32.2k, False: 0]
  ------------------
 4917|  32.2k|    return _impl_.const_oneof_.int_lit_;
 4918|  32.2k|  }
 4919|      0|  return 0u;
 4920|  32.2k|}
_ZNK11ruby_fuzzer5Const8bool_valEv:
 4942|  12.1k|inline bool Const::bool_val() const {
 4943|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Const.bool_val)
 4944|  12.1k|  return _internal_bool_val();
 4945|  12.1k|}
_ZNK11ruby_fuzzer5Const18_internal_bool_valEv:
 4950|  12.1k|inline bool Const::_internal_bool_val() const {
 4951|  12.1k|  if (const_oneof_case() == kBoolVal) {
  ------------------
  |  Branch (4951:7): [True: 12.1k, False: 0]
  ------------------
 4952|  12.1k|    return _impl_.const_oneof_.bool_val_;
 4953|  12.1k|  }
 4954|      0|  return false;
 4955|  12.1k|}
_ZNK11ruby_fuzzer5Const15has_const_oneofEv:
 4964|   291k|inline bool Const::has_const_oneof() const {
 4965|   291k|  return const_oneof_case() != CONST_ONEOF_NOT_SET;
 4966|   291k|}
_ZN11ruby_fuzzer5Const21clear_has_const_oneofEv:
 4967|   291k|inline void Const::clear_has_const_oneof() {
 4968|   291k|  _impl_._oneof_case_[0] = CONST_ONEOF_NOT_SET;
 4969|   291k|}
_ZNK11ruby_fuzzer5Const16const_oneof_caseEv:
 4970|   664k|inline Const::ConstOneofCase Const::const_oneof_case() const {
 4971|   664k|  return Const::ConstOneofCase(_impl_._oneof_case_[0]);
 4972|   664k|}
_ZNK11ruby_fuzzer8BinaryOp2opEv:
 4986|   130k|inline ::ruby_fuzzer::BinaryOp_Op BinaryOp::op() const {
 4987|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BinaryOp.op)
 4988|   130k|  return _internal_op();
 4989|   130k|}
_ZNK11ruby_fuzzer8BinaryOp12_internal_opEv:
 4994|   130k|inline ::ruby_fuzzer::BinaryOp_Op BinaryOp::_internal_op() const {
 4995|   130k|  return static_cast<::ruby_fuzzer::BinaryOp_Op>(_impl_.op_);
 4996|   130k|}
_ZNK11ruby_fuzzer8BinaryOp14_internal_leftEv:
 5013|   130k|inline const ::ruby_fuzzer::Rvalue& BinaryOp::_internal_left() const {
 5014|   130k|  const ::ruby_fuzzer::Rvalue* p = _impl_.left_;
 5015|   130k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5015:10): [True: 130k, False: 0]
  ------------------
 5016|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5017|   130k|}
_ZNK11ruby_fuzzer8BinaryOp4leftEv:
 5018|   130k|inline const ::ruby_fuzzer::Rvalue& BinaryOp::left() const {
 5019|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BinaryOp.left)
 5020|   130k|  return _internal_left();
 5021|   130k|}
_ZNK11ruby_fuzzer8BinaryOp15_internal_rightEv:
 5100|   130k|inline const ::ruby_fuzzer::Rvalue& BinaryOp::_internal_right() const {
 5101|   130k|  const ::ruby_fuzzer::Rvalue* p = _impl_.right_;
 5102|   130k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5102:10): [True: 130k, False: 0]
  ------------------
 5103|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5104|   130k|}
_ZNK11ruby_fuzzer8BinaryOp5rightEv:
 5105|   130k|inline const ::ruby_fuzzer::Rvalue& BinaryOp::right() const {
 5106|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BinaryOp.right)
 5107|   130k|  return _internal_right();
 5108|   130k|}
_ZNK11ruby_fuzzer6Rvalue16_internal_varrefEv:
 5213|  72.8k|inline const ::ruby_fuzzer::VarRef& Rvalue::_internal_varref() const {
 5214|  72.8k|  return rvalue_oneof_case() == kVarref
  ------------------
  |  Branch (5214:10): [True: 72.8k, False: 0]
  ------------------
 5215|  72.8k|      ? *_impl_.rvalue_oneof_.varref_
 5216|  72.8k|      : reinterpret_cast< ::ruby_fuzzer::VarRef&>(::ruby_fuzzer::_VarRef_default_instance_);
 5217|  72.8k|}
_ZNK11ruby_fuzzer6Rvalue6varrefEv:
 5218|  72.8k|inline const ::ruby_fuzzer::VarRef& Rvalue::varref() const {
 5219|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Rvalue.varref)
 5220|  72.8k|  return _internal_varref();
 5221|  72.8k|}
_ZNK11ruby_fuzzer6Rvalue14_internal_consEv:
 5287|  38.2k|inline const ::ruby_fuzzer::Const& Rvalue::_internal_cons() const {
 5288|  38.2k|  return rvalue_oneof_case() == kCons
  ------------------
  |  Branch (5288:10): [True: 38.2k, False: 0]
  ------------------
 5289|  38.2k|      ? *_impl_.rvalue_oneof_.cons_
 5290|  38.2k|      : reinterpret_cast< ::ruby_fuzzer::Const&>(::ruby_fuzzer::_Const_default_instance_);
 5291|  38.2k|}
_ZNK11ruby_fuzzer6Rvalue4consEv:
 5292|  38.2k|inline const ::ruby_fuzzer::Const& Rvalue::cons() const {
 5293|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Rvalue.cons)
 5294|  38.2k|  return _internal_cons();
 5295|  38.2k|}
_ZNK11ruby_fuzzer6Rvalue15_internal_binopEv:
 5361|   130k|inline const ::ruby_fuzzer::BinaryOp& Rvalue::_internal_binop() const {
 5362|   130k|  return rvalue_oneof_case() == kBinop
  ------------------
  |  Branch (5362:10): [True: 130k, False: 0]
  ------------------
 5363|   130k|      ? *_impl_.rvalue_oneof_.binop_
 5364|   130k|      : reinterpret_cast< ::ruby_fuzzer::BinaryOp&>(::ruby_fuzzer::_BinaryOp_default_instance_);
 5365|   130k|}
_ZNK11ruby_fuzzer6Rvalue5binopEv:
 5366|   130k|inline const ::ruby_fuzzer::BinaryOp& Rvalue::binop() const {
 5367|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Rvalue.binop)
 5368|   130k|  return _internal_binop();
 5369|   130k|}
_ZNK11ruby_fuzzer6Rvalue16has_rvalue_oneofEv:
 5403|   580k|inline bool Rvalue::has_rvalue_oneof() const {
 5404|   580k|  return rvalue_oneof_case() != RVALUE_ONEOF_NOT_SET;
 5405|   580k|}
_ZN11ruby_fuzzer6Rvalue22clear_has_rvalue_oneofEv:
 5406|   580k|inline void Rvalue::clear_has_rvalue_oneof() {
 5407|   580k|  _impl_._oneof_case_[0] = RVALUE_ONEOF_NOT_SET;
 5408|   580k|}
_ZNK11ruby_fuzzer6Rvalue17rvalue_oneof_caseEv:
 5409|  1.64M|inline Rvalue::RvalueOneofCase Rvalue::rvalue_oneof_case() const {
 5410|  1.64M|  return Rvalue::RvalueOneofCase(_impl_._oneof_case_[0]);
 5411|  1.64M|}
_ZNK11ruby_fuzzer19AssignmentStatement16_internal_rvalueEv:
 5426|   212k|inline const ::ruby_fuzzer::Rvalue& AssignmentStatement::_internal_rvalue() const {
 5427|   212k|  const ::ruby_fuzzer::Rvalue* p = _impl_.rvalue_;
 5428|   212k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5428:10): [True: 212k, False: 0]
  ------------------
 5429|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5430|   212k|}
_ZNK11ruby_fuzzer19AssignmentStatement6rvalueEv:
 5431|   212k|inline const ::ruby_fuzzer::Rvalue& AssignmentStatement::rvalue() const {
 5432|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.AssignmentStatement.rvalue)
 5433|   212k|  return _internal_rvalue();
 5434|   212k|}
_ZNK11ruby_fuzzer6IfElse14_internal_condEv:
 5517|  17.5k|inline const ::ruby_fuzzer::Rvalue& IfElse::_internal_cond() const {
 5518|  17.5k|  const ::ruby_fuzzer::Rvalue* p = _impl_.cond_;
 5519|  17.5k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5519:10): [True: 17.5k, False: 0]
  ------------------
 5520|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5521|  17.5k|}
_ZNK11ruby_fuzzer6IfElse4condEv:
 5522|  17.5k|inline const ::ruby_fuzzer::Rvalue& IfElse::cond() const {
 5523|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.IfElse.cond)
 5524|  17.5k|  return _internal_cond();
 5525|  17.5k|}
_ZNK11ruby_fuzzer6IfElse17_internal_if_bodyEv:
 5604|  17.5k|inline const ::ruby_fuzzer::StatementSeq& IfElse::_internal_if_body() const {
 5605|  17.5k|  const ::ruby_fuzzer::StatementSeq* p = _impl_.if_body_;
 5606|  17.5k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::StatementSeq&>(
  ------------------
  |  Branch (5606:10): [True: 17.5k, False: 0]
  ------------------
 5607|      0|      ::ruby_fuzzer::_StatementSeq_default_instance_);
 5608|  17.5k|}
_ZNK11ruby_fuzzer6IfElse7if_bodyEv:
 5609|  17.5k|inline const ::ruby_fuzzer::StatementSeq& IfElse::if_body() const {
 5610|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.IfElse.if_body)
 5611|  17.5k|  return _internal_if_body();
 5612|  17.5k|}
_ZNK11ruby_fuzzer6IfElse19_internal_else_bodyEv:
 5691|  17.5k|inline const ::ruby_fuzzer::StatementSeq& IfElse::_internal_else_body() const {
 5692|  17.5k|  const ::ruby_fuzzer::StatementSeq* p = _impl_.else_body_;
 5693|  17.5k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::StatementSeq&>(
  ------------------
  |  Branch (5693:10): [True: 17.5k, False: 0]
  ------------------
 5694|      0|      ::ruby_fuzzer::_StatementSeq_default_instance_);
 5695|  17.5k|}
_ZNK11ruby_fuzzer6IfElse9else_bodyEv:
 5696|  17.5k|inline const ::ruby_fuzzer::StatementSeq& IfElse::else_body() const {
 5697|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.IfElse.else_body)
 5698|  17.5k|  return _internal_else_body();
 5699|  17.5k|}
_ZNK11ruby_fuzzer7Ternary19_internal_tern_condEv:
 5782|  8.56k|inline const ::ruby_fuzzer::Rvalue& Ternary::_internal_tern_cond() const {
 5783|  8.56k|  const ::ruby_fuzzer::Rvalue* p = _impl_.tern_cond_;
 5784|  8.56k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5784:10): [True: 8.56k, False: 0]
  ------------------
 5785|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5786|  8.56k|}
_ZNK11ruby_fuzzer7Ternary9tern_condEv:
 5787|  8.56k|inline const ::ruby_fuzzer::Rvalue& Ternary::tern_cond() const {
 5788|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Ternary.tern_cond)
 5789|  8.56k|  return _internal_tern_cond();
 5790|  8.56k|}
_ZNK11ruby_fuzzer7Ternary18_internal_t_branchEv:
 5869|  8.56k|inline const ::ruby_fuzzer::Rvalue& Ternary::_internal_t_branch() const {
 5870|  8.56k|  const ::ruby_fuzzer::Rvalue* p = _impl_.t_branch_;
 5871|  8.56k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5871:10): [True: 8.56k, False: 0]
  ------------------
 5872|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5873|  8.56k|}
_ZNK11ruby_fuzzer7Ternary8t_branchEv:
 5874|  8.56k|inline const ::ruby_fuzzer::Rvalue& Ternary::t_branch() const {
 5875|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Ternary.t_branch)
 5876|  8.56k|  return _internal_t_branch();
 5877|  8.56k|}
_ZNK11ruby_fuzzer7Ternary18_internal_f_branchEv:
 5956|  8.56k|inline const ::ruby_fuzzer::Rvalue& Ternary::_internal_f_branch() const {
 5957|  8.56k|  const ::ruby_fuzzer::Rvalue* p = _impl_.f_branch_;
 5958|  8.56k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (5958:10): [True: 8.56k, False: 0]
  ------------------
 5959|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 5960|  8.56k|}
_ZNK11ruby_fuzzer7Ternary8f_branchEv:
 5961|  8.56k|inline const ::ruby_fuzzer::Rvalue& Ternary::f_branch() const {
 5962|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Ternary.f_branch)
 5963|  8.56k|  return _internal_f_branch();
 5964|  8.56k|}
_ZNK11ruby_fuzzer11ObjectSpace7os_funcEv:
 6046|  20.6k|inline ::ruby_fuzzer::ObjectSpace_OS_methods ObjectSpace::os_func() const {
 6047|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.ObjectSpace.os_func)
 6048|  20.6k|  return _internal_os_func();
 6049|  20.6k|}
_ZNK11ruby_fuzzer11ObjectSpace17_internal_os_funcEv:
 6054|  20.6k|inline ::ruby_fuzzer::ObjectSpace_OS_methods ObjectSpace::_internal_os_func() const {
 6055|  20.6k|  return static_cast<::ruby_fuzzer::ObjectSpace_OS_methods>(_impl_.os_func_);
 6056|  20.6k|}
_ZNK11ruby_fuzzer11ObjectSpace16_internal_os_argEv:
 6073|  20.6k|inline const ::ruby_fuzzer::HashType& ObjectSpace::_internal_os_arg() const {
 6074|  20.6k|  const ::ruby_fuzzer::HashType* p = _impl_.os_arg_;
 6075|  20.6k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::HashType&>(
  ------------------
  |  Branch (6075:10): [True: 20.6k, False: 0]
  ------------------
 6076|      0|      ::ruby_fuzzer::_HashType_default_instance_);
 6077|  20.6k|}
_ZNK11ruby_fuzzer11ObjectSpace6os_argEv:
 6078|  20.6k|inline const ::ruby_fuzzer::HashType& ObjectSpace::os_arg() const {
 6079|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.ObjectSpace.os_arg)
 6080|  20.6k|  return _internal_os_arg();
 6081|  20.6k|}
_ZNK11ruby_fuzzer4Time6t_funcEv:
 6163|  10.2k|inline ::ruby_fuzzer::Time_T_methods Time::t_func() const {
 6164|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Time.t_func)
 6165|  10.2k|  return _internal_t_func();
 6166|  10.2k|}
_ZNK11ruby_fuzzer4Time16_internal_t_funcEv:
 6171|  10.2k|inline ::ruby_fuzzer::Time_T_methods Time::_internal_t_func() const {
 6172|  10.2k|  return static_cast<::ruby_fuzzer::Time_T_methods>(_impl_.t_func_);
 6173|  10.2k|}
_ZNK11ruby_fuzzer4Time5t_argEv:
 6189|  10.2k|inline ::uint32_t Time::t_arg() const {
 6190|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Time.t_arg)
 6191|  10.2k|  return _internal_t_arg();
 6192|  10.2k|}
_ZNK11ruby_fuzzer4Time15_internal_t_argEv:
 6197|  10.2k|inline ::uint32_t Time::_internal_t_arg() const {
 6198|  10.2k|  return _impl_.t_arg_;
 6199|  10.2k|}
_ZNK11ruby_fuzzer5Array8arr_funcEv:
 6218|  55.7k|inline ::ruby_fuzzer::Array_Arr_methods Array::arr_func() const {
 6219|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Array.arr_func)
 6220|  55.7k|  return _internal_arr_func();
 6221|  55.7k|}
_ZNK11ruby_fuzzer5Array18_internal_arr_funcEv:
 6226|  55.7k|inline ::ruby_fuzzer::Array_Arr_methods Array::_internal_arr_func() const {
 6227|  55.7k|  return static_cast<::ruby_fuzzer::Array_Arr_methods>(_impl_.arr_func_);
 6228|  55.7k|}
_ZNK11ruby_fuzzer5Array17_internal_arr_argEv:
 6245|  55.7k|inline const ::ruby_fuzzer::ArrType& Array::_internal_arr_arg() const {
 6246|  55.7k|  const ::ruby_fuzzer::ArrType* p = _impl_.arr_arg_;
 6247|  55.7k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::ArrType&>(
  ------------------
  |  Branch (6247:10): [True: 55.7k, False: 0]
  ------------------
 6248|      0|      ::ruby_fuzzer::_ArrType_default_instance_);
 6249|  55.7k|}
_ZNK11ruby_fuzzer5Array7arr_argEv:
 6250|  55.7k|inline const ::ruby_fuzzer::ArrType& Array::arr_arg() const {
 6251|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Array.arr_arg)
 6252|  55.7k|  return _internal_arr_arg();
 6253|  55.7k|}
_ZNK11ruby_fuzzer5Array17_internal_val_argEv:
 6332|  55.7k|inline const ::ruby_fuzzer::Rvalue& Array::_internal_val_arg() const {
 6333|  55.7k|  const ::ruby_fuzzer::Rvalue* p = _impl_.val_arg_;
 6334|  55.7k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
  ------------------
  |  Branch (6334:10): [True: 55.7k, False: 0]
  ------------------
 6335|      0|      ::ruby_fuzzer::_Rvalue_default_instance_);
 6336|  55.7k|}
_ZNK11ruby_fuzzer5Array7val_argEv:
 6337|  55.7k|inline const ::ruby_fuzzer::Rvalue& Array::val_arg() const {
 6338|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Array.val_arg)
 6339|  55.7k|  return _internal_val_arg();
 6340|  55.7k|}
_ZNK11ruby_fuzzer8MathType19_internal_math_rvalEv:
 6445|  1.32k|inline const ::ruby_fuzzer::Rvalue& MathType::_internal_math_rval() const {
 6446|  1.32k|  return math_arg_oneof_case() == kMathRval
  ------------------
  |  Branch (6446:10): [True: 1.32k, False: 0]
  ------------------
 6447|  1.32k|      ? *_impl_.math_arg_oneof_.math_rval_
 6448|  1.32k|      : reinterpret_cast< ::ruby_fuzzer::Rvalue&>(::ruby_fuzzer::_Rvalue_default_instance_);
 6449|  1.32k|}
_ZNK11ruby_fuzzer8MathType9math_rvalEv:
 6450|  1.32k|inline const ::ruby_fuzzer::Rvalue& MathType::math_rval() const {
 6451|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathType.math_rval)
 6452|  1.32k|  return _internal_math_rval();
 6453|  1.32k|}
_ZNK11ruby_fuzzer8MathType20_internal_math_constEv:
 6519|  3.08k|inline const ::ruby_fuzzer::MathConst& MathType::_internal_math_const() const {
 6520|  3.08k|  return math_arg_oneof_case() == kMathConst
  ------------------
  |  Branch (6520:10): [True: 3.08k, False: 0]
  ------------------
 6521|  3.08k|      ? *_impl_.math_arg_oneof_.math_const_
 6522|  3.08k|      : reinterpret_cast< ::ruby_fuzzer::MathConst&>(::ruby_fuzzer::_MathConst_default_instance_);
 6523|  3.08k|}
_ZNK11ruby_fuzzer8MathType10math_constEv:
 6524|  3.08k|inline const ::ruby_fuzzer::MathConst& MathType::math_const() const {
 6525|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathType.math_const)
 6526|  3.08k|  return _internal_math_const();
 6527|  3.08k|}
_ZNK11ruby_fuzzer8MathType18has_math_arg_oneofEv:
 6561|  9.45k|inline bool MathType::has_math_arg_oneof() const {
 6562|  9.45k|  return math_arg_oneof_case() != MATH_ARG_ONEOF_NOT_SET;
 6563|  9.45k|}
_ZN11ruby_fuzzer8MathType24clear_has_math_arg_oneofEv:
 6564|  9.45k|inline void MathType::clear_has_math_arg_oneof() {
 6565|  9.45k|  _impl_._oneof_case_[0] = MATH_ARG_ONEOF_NOT_SET;
 6566|  9.45k|}
_ZNK11ruby_fuzzer8MathType19math_arg_oneof_caseEv:
 6567|  27.8k|inline MathType::MathArgOneofCase MathType::math_arg_oneof_case() const {
 6568|  27.8k|  return MathType::MathArgOneofCase(_impl_._oneof_case_[0]);
 6569|  27.8k|}
_ZNK11ruby_fuzzer7MathOps7math_opEv:
 6583|  9.19k|inline ::ruby_fuzzer::MathOps_Mops MathOps::math_op() const {
 6584|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathOps.math_op)
 6585|  9.19k|  return _internal_math_op();
 6586|  9.19k|}
_ZNK11ruby_fuzzer7MathOps17_internal_math_opEv:
 6591|  9.19k|inline ::ruby_fuzzer::MathOps_Mops MathOps::_internal_math_op() const {
 6592|  9.19k|  return static_cast<::ruby_fuzzer::MathOps_Mops>(_impl_.math_op_);
 6593|  9.19k|}
_ZNK11ruby_fuzzer7MathOps18_internal_math_argEv:
 6610|  9.19k|inline const ::ruby_fuzzer::MathType& MathOps::_internal_math_arg() const {
 6611|  9.19k|  const ::ruby_fuzzer::MathType* p = _impl_.math_arg_;
 6612|  9.19k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::MathType&>(
  ------------------
  |  Branch (6612:10): [True: 9.19k, False: 0]
  ------------------
 6613|      0|      ::ruby_fuzzer::_MathType_default_instance_);
 6614|  9.19k|}
_ZNK11ruby_fuzzer7MathOps8math_argEv:
 6615|  9.19k|inline const ::ruby_fuzzer::MathType& MathOps::math_arg() const {
 6616|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathOps.math_arg)
 6617|  9.19k|  return _internal_math_arg();
 6618|  9.19k|}
_ZNK11ruby_fuzzer12BuiltinFuncs12_internal_osEv:
 6723|  20.6k|inline const ::ruby_fuzzer::ObjectSpace& BuiltinFuncs::_internal_os() const {
 6724|  20.6k|  return bifunc_oneof_case() == kOs
  ------------------
  |  Branch (6724:10): [True: 20.6k, False: 0]
  ------------------
 6725|  20.6k|      ? *_impl_.bifunc_oneof_.os_
 6726|  20.6k|      : reinterpret_cast< ::ruby_fuzzer::ObjectSpace&>(::ruby_fuzzer::_ObjectSpace_default_instance_);
 6727|  20.6k|}
_ZNK11ruby_fuzzer12BuiltinFuncs2osEv:
 6728|  20.6k|inline const ::ruby_fuzzer::ObjectSpace& BuiltinFuncs::os() const {
 6729|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.os)
 6730|  20.6k|  return _internal_os();
 6731|  20.6k|}
_ZNK11ruby_fuzzer12BuiltinFuncs14_internal_timeEv:
 6797|  10.2k|inline const ::ruby_fuzzer::Time& BuiltinFuncs::_internal_time() const {
 6798|  10.2k|  return bifunc_oneof_case() == kTime
  ------------------
  |  Branch (6798:10): [True: 10.2k, False: 0]
  ------------------
 6799|  10.2k|      ? *_impl_.bifunc_oneof_.time_
 6800|  10.2k|      : reinterpret_cast< ::ruby_fuzzer::Time&>(::ruby_fuzzer::_Time_default_instance_);
 6801|  10.2k|}
_ZNK11ruby_fuzzer12BuiltinFuncs4timeEv:
 6802|  10.2k|inline const ::ruby_fuzzer::Time& BuiltinFuncs::time() const {
 6803|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.time)
 6804|  10.2k|  return _internal_time();
 6805|  10.2k|}
_ZNK11ruby_fuzzer12BuiltinFuncs13_internal_arrEv:
 6871|  55.7k|inline const ::ruby_fuzzer::Array& BuiltinFuncs::_internal_arr() const {
 6872|  55.7k|  return bifunc_oneof_case() == kArr
  ------------------
  |  Branch (6872:10): [True: 55.7k, False: 0]
  ------------------
 6873|  55.7k|      ? *_impl_.bifunc_oneof_.arr_
 6874|  55.7k|      : reinterpret_cast< ::ruby_fuzzer::Array&>(::ruby_fuzzer::_Array_default_instance_);
 6875|  55.7k|}
_ZNK11ruby_fuzzer12BuiltinFuncs3arrEv:
 6876|  55.7k|inline const ::ruby_fuzzer::Array& BuiltinFuncs::arr() const {
 6877|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.arr)
 6878|  55.7k|  return _internal_arr();
 6879|  55.7k|}
_ZNK11ruby_fuzzer12BuiltinFuncs14_internal_mopsEv:
 6945|  9.19k|inline const ::ruby_fuzzer::MathOps& BuiltinFuncs::_internal_mops() const {
 6946|  9.19k|  return bifunc_oneof_case() == kMops
  ------------------
  |  Branch (6946:10): [True: 9.19k, False: 0]
  ------------------
 6947|  9.19k|      ? *_impl_.bifunc_oneof_.mops_
 6948|  9.19k|      : reinterpret_cast< ::ruby_fuzzer::MathOps&>(::ruby_fuzzer::_MathOps_default_instance_);
 6949|  9.19k|}
_ZNK11ruby_fuzzer12BuiltinFuncs4mopsEv:
 6950|  9.19k|inline const ::ruby_fuzzer::MathOps& BuiltinFuncs::mops() const {
 6951|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.mops)
 6952|  9.19k|  return _internal_mops();
 6953|  9.19k|}
_ZNK11ruby_fuzzer12BuiltinFuncs16has_bifunc_oneofEv:
 6987|   119k|inline bool BuiltinFuncs::has_bifunc_oneof() const {
 6988|   119k|  return bifunc_oneof_case() != BIFUNC_ONEOF_NOT_SET;
 6989|   119k|}
_ZN11ruby_fuzzer12BuiltinFuncs22clear_has_bifunc_oneofEv:
 6990|   119k|inline void BuiltinFuncs::clear_has_bifunc_oneof() {
 6991|   119k|  _impl_._oneof_case_[0] = BIFUNC_ONEOF_NOT_SET;
 6992|   119k|}
_ZNK11ruby_fuzzer12BuiltinFuncs17bifunc_oneof_caseEv:
 6993|   431k|inline BuiltinFuncs::BifuncOneofCase BuiltinFuncs::bifunc_oneof_case() const {
 6994|   431k|  return BuiltinFuncs::BifuncOneofCase(_impl_._oneof_case_[0]);
 6995|   431k|}
_ZNK11ruby_fuzzer9Statement20_internal_assignmentEv:
 7032|   212k|inline const ::ruby_fuzzer::AssignmentStatement& Statement::_internal_assignment() const {
 7033|   212k|  return stmt_oneof_case() == kAssignment
  ------------------
  |  Branch (7033:10): [True: 212k, False: 0]
  ------------------
 7034|   212k|      ? *_impl_.stmt_oneof_.assignment_
 7035|   212k|      : reinterpret_cast< ::ruby_fuzzer::AssignmentStatement&>(::ruby_fuzzer::_AssignmentStatement_default_instance_);
 7036|   212k|}
_ZNK11ruby_fuzzer9Statement10assignmentEv:
 7037|   212k|inline const ::ruby_fuzzer::AssignmentStatement& Statement::assignment() const {
 7038|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.assignment)
 7039|   212k|  return _internal_assignment();
 7040|   212k|}
_ZNK11ruby_fuzzer9Statement16_internal_ifelseEv:
 7106|  17.5k|inline const ::ruby_fuzzer::IfElse& Statement::_internal_ifelse() const {
 7107|  17.5k|  return stmt_oneof_case() == kIfelse
  ------------------
  |  Branch (7107:10): [True: 17.5k, False: 0]
  ------------------
 7108|  17.5k|      ? *_impl_.stmt_oneof_.ifelse_
 7109|  17.5k|      : reinterpret_cast< ::ruby_fuzzer::IfElse&>(::ruby_fuzzer::_IfElse_default_instance_);
 7110|  17.5k|}
_ZNK11ruby_fuzzer9Statement6ifelseEv:
 7111|  17.5k|inline const ::ruby_fuzzer::IfElse& Statement::ifelse() const {
 7112|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.ifelse)
 7113|  17.5k|  return _internal_ifelse();
 7114|  17.5k|}
_ZNK11ruby_fuzzer9Statement22_internal_ternary_stmtEv:
 7180|  8.56k|inline const ::ruby_fuzzer::Ternary& Statement::_internal_ternary_stmt() const {
 7181|  8.56k|  return stmt_oneof_case() == kTernaryStmt
  ------------------
  |  Branch (7181:10): [True: 8.56k, False: 0]
  ------------------
 7182|  8.56k|      ? *_impl_.stmt_oneof_.ternary_stmt_
 7183|  8.56k|      : reinterpret_cast< ::ruby_fuzzer::Ternary&>(::ruby_fuzzer::_Ternary_default_instance_);
 7184|  8.56k|}
_ZNK11ruby_fuzzer9Statement12ternary_stmtEv:
 7185|  8.56k|inline const ::ruby_fuzzer::Ternary& Statement::ternary_stmt() const {
 7186|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.ternary_stmt)
 7187|  8.56k|  return _internal_ternary_stmt();
 7188|  8.56k|}
_ZNK11ruby_fuzzer9Statement18_internal_builtinsEv:
 7254|   118k|inline const ::ruby_fuzzer::BuiltinFuncs& Statement::_internal_builtins() const {
 7255|   118k|  return stmt_oneof_case() == kBuiltins
  ------------------
  |  Branch (7255:10): [True: 118k, False: 0]
  ------------------
 7256|   118k|      ? *_impl_.stmt_oneof_.builtins_
 7257|   118k|      : reinterpret_cast< ::ruby_fuzzer::BuiltinFuncs&>(::ruby_fuzzer::_BuiltinFuncs_default_instance_);
 7258|   118k|}
_ZNK11ruby_fuzzer9Statement8builtinsEv:
 7259|   118k|inline const ::ruby_fuzzer::BuiltinFuncs& Statement::builtins() const {
 7260|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.builtins)
 7261|   118k|  return _internal_builtins();
 7262|   118k|}
_ZNK11ruby_fuzzer9Statement19_internal_blockstmtEv:
 7328|  33.0k|inline const ::ruby_fuzzer::StatementSeq& Statement::_internal_blockstmt() const {
 7329|  33.0k|  return stmt_oneof_case() == kBlockstmt
  ------------------
  |  Branch (7329:10): [True: 33.0k, False: 0]
  ------------------
 7330|  33.0k|      ? *_impl_.stmt_oneof_.blockstmt_
 7331|  33.0k|      : reinterpret_cast< ::ruby_fuzzer::StatementSeq&>(::ruby_fuzzer::_StatementSeq_default_instance_);
 7332|  33.0k|}
_ZNK11ruby_fuzzer9Statement9blockstmtEv:
 7333|  33.0k|inline const ::ruby_fuzzer::StatementSeq& Statement::blockstmt() const {
 7334|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.blockstmt)
 7335|  33.0k|  return _internal_blockstmt();
 7336|  33.0k|}
_ZNK11ruby_fuzzer9Statement14has_stmt_oneofEv:
 7370|   554k|inline bool Statement::has_stmt_oneof() const {
 7371|   554k|  return stmt_oneof_case() != STMT_ONEOF_NOT_SET;
 7372|   554k|}
_ZN11ruby_fuzzer9Statement20clear_has_stmt_oneofEv:
 7373|   554k|inline void Statement::clear_has_stmt_oneof() {
 7374|   554k|  _impl_._oneof_case_[0] = STMT_ONEOF_NOT_SET;
 7375|   554k|}
_ZNK11ruby_fuzzer9Statement15stmt_oneof_caseEv:
 7376|  1.89M|inline Statement::StmtOneofCase Statement::stmt_oneof_case() const {
 7377|  1.89M|  return Statement::StmtOneofCase(_impl_._oneof_case_[0]);
 7378|  1.89M|}
_ZNK11ruby_fuzzer12StatementSeq25_internal_statements_sizeEv:
 7384|  69.8k|inline int StatementSeq::_internal_statements_size() const {
 7385|  69.8k|  return _impl_.statements_.size();
 7386|  69.8k|}
_ZNK11ruby_fuzzer12StatementSeq15statements_sizeEv:
 7387|  69.8k|inline int StatementSeq::statements_size() const {
 7388|  69.8k|  return _internal_statements_size();
 7389|  69.8k|}
_ZNK11ruby_fuzzer12StatementSeq10statementsEv:
 7418|  31.8k|StatementSeq::statements() const {
 7419|       |  // @@protoc_insertion_point(field_list:ruby_fuzzer.StatementSeq.statements)
 7420|  31.8k|  return _impl_.statements_;
 7421|  31.8k|}
_ZNK11ruby_fuzzer8Function20_internal_statementsEv:
 7437|  1.74k|inline const ::ruby_fuzzer::StatementSeq& Function::_internal_statements() const {
 7438|  1.74k|  const ::ruby_fuzzer::StatementSeq* p = _impl_.statements_;
 7439|  1.74k|  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::StatementSeq&>(
  ------------------
  |  Branch (7439:10): [True: 1.74k, False: 0]
  ------------------
 7440|      0|      ::ruby_fuzzer::_StatementSeq_default_instance_);
 7441|  1.74k|}
_ZNK11ruby_fuzzer8Function10statementsEv:
 7442|  1.74k|inline const ::ruby_fuzzer::StatementSeq& Function::statements() const {
 7443|       |  // @@protoc_insertion_point(field_get:ruby_fuzzer.Function.statements)
 7444|  1.74k|  return _internal_statements();
 7445|  1.74k|}

gc.c:mrb_val_union:
  136|   664k|{
  137|   664k|  union mrb_value_ x;
  138|   664k|  x.value = v;
  139|   664k|  return x;
  140|   664k|}
array.c:mrb_val_union:
  136|   954k|{
  137|   954k|  union mrb_value_ x;
  138|   954k|  x.value = v;
  139|   954k|  return x;
  140|   954k|}
array.c:mrb_integer_func:
  162|  19.9k|mrb_integer_func(mrb_value o) {
  163|  19.9k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|  19.9k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  39.9k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 19.9k, False: 34]
  |  |  |  Branch (148:63): [True: 0, False: 34]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|  19.9k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|  19.9k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|  19.9k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|     34|  return mrb_val_union(o).ip->i;
  165|  19.9k|}
array.c:mrb_type:
  221|  2.25k|{
  222|  2.25k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|  2.25k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 0, False: 2.25k]
  ------------------
  223|  2.25k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  4.50k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 1, False: 2.25k]
  |  |  ------------------
  ------------------
  224|  2.25k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|  2.25k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  4.50k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 1.34k, False: 907]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  2.25k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|    907|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  1.81k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 907]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|    907|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|  1.81k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 907]
  |  |  ------------------
  ------------------
  227|    907|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|    907|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  1.81k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 873, False: 34]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|    907|         mrb_val_union(o).bp->tt;
  229|  2.25k|}
range.c:mrb_val_union:
  136|    112|{
  137|    112|  union mrb_value_ x;
  138|    112|  x.value = v;
  139|    112|  return x;
  140|    112|}
range.c:mrb_integer_func:
  162|    274|mrb_integer_func(mrb_value o) {
  163|    274|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|    274|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|    548|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 219, False: 55]
  |  |  |  Branch (148:63): [True: 0, False: 55]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|    219|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|    219|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|    219|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|     55|  return mrb_val_union(o).ip->i;
  165|    274|}
variable.c:mrb_val_union:
  136|  5.42M|{
  137|  5.42M|  union mrb_value_ x;
  138|  5.42M|  x.value = v;
  139|  5.42M|  return x;
  140|  5.42M|}
variable.c:mrb_type:
  221|  1.17M|{
  222|  1.17M|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|  1.17M|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 1.74k, False: 1.17M]
  ------------------
  223|  1.17M|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  2.34M|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 0, False: 1.17M]
  |  |  ------------------
  ------------------
  224|  1.17M|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|  1.17M|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  2.34M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 317k, False: 855k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  1.17M|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|   855k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  1.71M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 130k, False: 724k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|   855k|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|  1.44M|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 724k]
  |  |  ------------------
  ------------------
  227|   724k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|   724k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  1.44M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 12.2k, False: 712k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|   724k|         mrb_val_union(o).bp->tt;
  229|  1.17M|}
hash.c:mrb_val_union:
  136|  1.81M|{
  137|  1.81M|  union mrb_value_ x;
  138|  1.81M|  x.value = v;
  139|  1.81M|  return x;
  140|  1.81M|}
hash.c:mrb_type:
  221|  1.74M|{
  222|  1.74M|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|  1.74M|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 0, False: 1.74M]
  ------------------
  223|  1.74M|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  3.49M|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 0, False: 1.74M]
  |  |  ------------------
  ------------------
  224|  1.74M|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|  1.74M|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  3.49M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 1.74M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  1.74M|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|  1.74M|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  3.49M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 1.50M, False: 239k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|  1.74M|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|   479k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 239k]
  |  |  ------------------
  ------------------
  227|   239k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|   239k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|   479k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 239k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|   239k|         mrb_val_union(o).bp->tt;
  229|  1.74M|}
numeric.c:mrb_type:
  221|   111k|{
  222|   111k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|   111k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 446, False: 111k]
  ------------------
  223|   111k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|   222k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 471, False: 110k]
  |  |  ------------------
  ------------------
  224|   111k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|   110k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|   221k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 76.3k, False: 34.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|   110k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|  34.3k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  68.6k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 34.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|  34.3k|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|  68.6k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 34.3k]
  |  |  ------------------
  ------------------
  227|  34.3k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|  34.3k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  68.6k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 1.03k, False: 33.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|  34.3k|         mrb_val_union(o).bp->tt;
  229|   111k|}
numeric.c:mrb_integer_func:
  162|   146k|mrb_integer_func(mrb_value o) {
  163|   146k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|   146k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|   292k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 142k, False: 3.47k]
  |  |  |  Branch (148:63): [True: 0, False: 3.47k]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|   142k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|   142k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|   142k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|  3.47k|  return mrb_val_union(o).ip->i;
  165|   146k|}
numeric.c:mrb_val_union:
  136|  45.4k|{
  137|  45.4k|  union mrb_value_ x;
  138|  45.4k|  x.value = v;
  139|  45.4k|  return x;
  140|  45.4k|}
object.c:mrb_val_union:
  136|   135k|{
  137|   135k|  union mrb_value_ x;
  138|   135k|  x.value = v;
  139|   135k|  return x;
  140|   135k|}
object.c:mrb_integer_func:
  162|  4.24k|mrb_integer_func(mrb_value o) {
  163|  4.24k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|  4.24k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  8.49k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 4.20k, False: 38]
  |  |  |  Branch (148:63): [True: 0, False: 38]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|  4.20k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|  4.20k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|  4.20k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|     38|  return mrb_val_union(o).ip->i;
  165|  4.24k|}
object.c:mrb_type:
  221|   176k|{
  222|   176k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|   176k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 25, False: 176k]
  ------------------
  223|   176k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|   353k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 33, False: 176k]
  |  |  ------------------
  ------------------
  224|   176k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|   176k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|   353k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 119k, False: 57.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|   176k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|  57.1k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|   114k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 57.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|  57.1k|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|   114k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 57.1k]
  |  |  ------------------
  ------------------
  227|  57.1k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|  57.1k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|   114k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 3.60k, False: 53.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|  57.1k|         mrb_val_union(o).bp->tt;
  229|   176k|}
error.c:mrb_val_union:
  136|  19.1k|{
  137|  19.1k|  union mrb_value_ x;
  138|  19.1k|  x.value = v;
  139|  19.1k|  return x;
  140|  19.1k|}
error.c:mrb_type:
  221|    883|{
  222|    883|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|    883|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 18, False: 865]
  ------------------
  223|    883|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  1.73k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 9, False: 856]
  |  |  ------------------
  ------------------
  224|    865|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|    856|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  1.71k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 29, False: 827]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|    856|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|    827|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  1.65k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 827]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|    827|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|  1.65k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 827]
  |  |  ------------------
  ------------------
  227|    827|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|    827|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  1.65k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 7, False: 820]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|    827|         mrb_val_union(o).bp->tt;
  229|    883|}
vm.c:mrb_val_union:
  136|  2.98M|{
  137|  2.98M|  union mrb_value_ x;
  138|  2.98M|  x.value = v;
  139|  2.98M|  return x;
  140|  2.98M|}
vm.c:mrb_type:
  221|   618k|{
  222|   618k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|   618k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 7.58k, False: 611k]
  ------------------
  223|   618k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  1.22M|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 3.97k, False: 607k]
  |  |  ------------------
  ------------------
  224|   611k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|   607k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  1.21M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 438k, False: 168k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|   607k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|   168k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|   337k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 168k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|   168k|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|   337k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 168k]
  |  |  ------------------
  ------------------
  227|   168k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|   168k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|   337k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 18.1k, False: 150k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|   168k|         mrb_val_union(o).bp->tt;
  229|   618k|}
vm.c:mrb_integer_func:
  162|   380k|mrb_integer_func(mrb_value o) {
  163|   380k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|   380k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|   761k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 368k, False: 11.9k]
  |  |  |  Branch (148:63): [True: 0, False: 11.9k]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|   368k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|   368k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|   368k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|  11.9k|  return mrb_val_union(o).ip->i;
  165|   380k|}
class.c:mrb_val_union:
  136|  1.06M|{
  137|  1.06M|  union mrb_value_ x;
  138|  1.06M|  x.value = v;
  139|  1.06M|  return x;
  140|  1.06M|}
class.c:mrb_integer_func:
  162|  10.1k|mrb_integer_func(mrb_value o) {
  163|  10.1k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|  10.1k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  20.3k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 10.1k, False: 70]
  |  |  |  Branch (148:63): [True: 0, False: 70]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|  10.1k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|  10.1k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|  10.1k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|     70|  return mrb_val_union(o).ip->i;
  165|  10.1k|}
class.c:mrb_type:
  221|   320k|{
  222|   320k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|   320k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 0, False: 320k]
  ------------------
  223|   320k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|   640k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 0, False: 320k]
  |  |  ------------------
  ------------------
  224|   320k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|   320k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|   640k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 320k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|   320k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|   320k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|   640k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 320k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|   320k|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|   640k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 320k]
  |  |  ------------------
  ------------------
  227|   320k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|   320k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|   640k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 4, False: 320k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|   320k|         mrb_val_union(o).bp->tt;
  229|   320k|}
string.c:mrb_val_union:
  136|  1.27M|{
  137|  1.27M|  union mrb_value_ x;
  138|  1.27M|  x.value = v;
  139|  1.27M|  return x;
  140|  1.27M|}
string.c:mrb_type:
  221|    432|{
  222|    432|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|    432|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 0, False: 432]
  ------------------
  223|    432|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|    864|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 0, False: 432]
  |  |  ------------------
  ------------------
  224|    432|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|    432|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|    864|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 167, False: 265]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|    432|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|    265|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|    530|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 126, False: 139]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|    265|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|    278|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 139]
  |  |  ------------------
  ------------------
  227|    139|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|    139|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|    278|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 4, False: 135]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|    139|         mrb_val_union(o).bp->tt;
  229|    432|}
kernel.c:mrb_val_union:
  136|   977k|{
  137|   977k|  union mrb_value_ x;
  138|   977k|  x.value = v;
  139|   977k|  return x;
  140|   977k|}
kernel.c:mrb_type:
  221|    126|{
  222|    126|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|    126|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 63, False: 63]
  ------------------
  223|    126|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|    126|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 63, False: 0]
  |  |  ------------------
  ------------------
  224|     63|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|      0|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|      0|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|      0|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|      0|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|      0|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  227|      0|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|      0|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|      0|         mrb_val_union(o).bp->tt;
  229|    126|}
bigint.c:mrb_val_union:
  136|  87.4k|{
  137|  87.4k|  union mrb_value_ x;
  138|  87.4k|  x.value = v;
  139|  87.4k|  return x;
  140|  87.4k|}
bigint.c:mrb_type:
  221|  25.0k|{
  222|  25.0k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|  25.0k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 9, False: 25.0k]
  ------------------
  223|  25.0k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  50.1k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 7, False: 25.0k]
  |  |  ------------------
  ------------------
  224|  25.0k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|  25.0k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  50.1k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 9.78k, False: 15.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  25.0k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|  15.2k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  30.5k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 15.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|  15.2k|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|  30.5k|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 15.2k]
  |  |  ------------------
  ------------------
  227|  15.2k|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|  15.2k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  30.5k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 15.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|  15.2k|         mrb_val_union(o).bp->tt;
  229|  25.0k|}
bigint.c:mrb_integer_func:
  162|  14.8k|mrb_integer_func(mrb_value o) {
  163|  14.8k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|  14.8k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  29.7k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 11.5k, False: 3.37k]
  |  |  |  Branch (148:63): [True: 0, False: 3.37k]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|  11.5k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|  11.5k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|  11.5k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|  3.37k|  return mrb_val_union(o).ip->i;
  165|  14.8k|}
y.tab.c:mrb_val_union:
  136|    203|{
  137|    203|  union mrb_value_ x;
  138|    203|  x.value = v;
  139|    203|  return x;
  140|    203|}
backtrace.c:mrb_val_union:
  136|    860|{
  137|    860|  union mrb_value_ x;
  138|    860|  x.value = v;
  139|    860|  return x;
  140|    860|}
time.c:mrb_type:
  221|  7.53k|{
  222|  7.53k|  return !mrb_bool(o)    ? MRB_TT_FALSE :
  ------------------
  |  |  168|  7.53k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  ------------------
  |  Branch (222:10): [True: 0, False: 7.53k]
  ------------------
  223|  7.53k|         mrb_true_p(o)   ? MRB_TT_TRUE :
  ------------------
  |  |  176|  15.0k|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 0, False: 7.53k]
  |  |  ------------------
  ------------------
  224|  7.53k|         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
  ------------------
  |  |  170|  7.53k|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|  15.0k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 7.53k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  7.53k|         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
  ------------------
  |  |  172|      0|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|      0|         mrb_undef_p(o)  ? MRB_TT_UNDEF :
  ------------------
  |  |  173|      0|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  227|      0|         mrb_float_p(o)  ? MRB_TT_FLOAT :
  ------------------
  |  |  179|      0|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|      0|         mrb_val_union(o).bp->tt;
  229|  7.53k|}
time.c:mrb_integer_func:
  162|  7.53k|mrb_integer_func(mrb_value o) {
  163|  7.53k|  if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  148|  7.53k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  15.0k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 7.53k, False: 0]
  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                if (mrb_immediate_p(o)) return mrb_fixnum(o);
  ------------------
  |  |  160|  7.53k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|  7.53k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|  7.53k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|      0|  return mrb_val_union(o).ip->i;
  165|  7.53k|}
time.c:mrb_val_union:
  136|  7.54k|{
  137|  7.54k|  union mrb_value_ x;
  138|  7.54k|  x.value = v;
  139|  7.54k|  return x;
  140|  7.54k|}
random.c:mrb_val_union:
  136|  3.49k|{
  137|  3.49k|  union mrb_value_ x;
  138|  3.49k|  x.value = v;
  139|  3.49k|  return x;
  140|  3.49k|}
io.c:mrb_val_union:
  136|  20.9k|{
  137|  20.9k|  union mrb_value_ x;
  138|  20.9k|  x.value = v;
  139|  20.9k|  return x;
  140|  20.9k|}

object.c:mrb_class:
   28|  40.8k|{
   29|  40.8k|  if (!mrb_immediate_p(v)) {
  ------------------
  |  |  148|  40.8k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  81.7k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 29.5k, False: 11.3k]
  |  |  |  Branch (148:63): [True: 0, False: 11.3k]
  |  |  ------------------
  ------------------
   30|  11.3k|    return mrb_obj_ptr(v)->c;
  ------------------
  |  |   34|  11.3k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  11.3k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   31|  11.3k|  }
   32|       |
   33|  29.5k|  switch (mrb_type(v)) {
   34|      0|  case MRB_TT_FALSE:
  ------------------
  |  Branch (34:3): [True: 0, False: 29.5k]
  ------------------
   35|      0|    if (mrb_fixnum(v))
  ------------------
  |  |  160|      0|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|      0|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|      0|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   36|      0|      return mrb->false_class;
   37|      0|    return mrb->nil_class;
   38|      0|  case MRB_TT_TRUE:
  ------------------
  |  Branch (38:3): [True: 0, False: 29.5k]
  ------------------
   39|      0|    return mrb->true_class;
   40|      0|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (40:3): [True: 0, False: 29.5k]
  ------------------
   41|      0|    return mrb->symbol_class;
   42|  29.5k|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (42:3): [True: 29.5k, False: 0]
  ------------------
   43|  29.5k|    return mrb->integer_class;
   44|      0|#ifndef MRB_NO_FLOAT
   45|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (45:3): [True: 0, False: 29.5k]
  ------------------
   46|      0|    return mrb->float_class;
   47|      0|#endif
   48|      0|  case MRB_TT_CPTR:
  ------------------
  |  Branch (48:3): [True: 0, False: 29.5k]
  ------------------
   49|      0|    return mrb->object_class;
   50|      0|  default:
  ------------------
  |  Branch (50:3): [True: 0, False: 29.5k]
  ------------------
   51|      0|    return NULL;
   52|  29.5k|  }
   53|  29.5k|}
error.c:mrb_class:
   28|     92|{
   29|     92|  if (!mrb_immediate_p(v)) {
  ------------------
  |  |  148|     92|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|    184|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 63, False: 29]
  |  |  |  Branch (148:63): [True: 0, False: 29]
  |  |  ------------------
  ------------------
   30|     29|    return mrb_obj_ptr(v)->c;
  ------------------
  |  |   34|     29|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|     29|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   31|     29|  }
   32|       |
   33|     63|  switch (mrb_type(v)) {
   34|     18|  case MRB_TT_FALSE:
  ------------------
  |  Branch (34:3): [True: 18, False: 45]
  ------------------
   35|     18|    if (mrb_fixnum(v))
  ------------------
  |  |  160|     18|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|     18|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|     18|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:24): [True: 18, False: 0]
  |  |  ------------------
  ------------------
   36|     18|      return mrb->false_class;
   37|      0|    return mrb->nil_class;
   38|      9|  case MRB_TT_TRUE:
  ------------------
  |  Branch (38:3): [True: 9, False: 54]
  ------------------
   39|      9|    return mrb->true_class;
   40|      0|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (40:3): [True: 0, False: 63]
  ------------------
   41|      0|    return mrb->symbol_class;
   42|     29|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (42:3): [True: 29, False: 34]
  ------------------
   43|     29|    return mrb->integer_class;
   44|      0|#ifndef MRB_NO_FLOAT
   45|      7|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (45:3): [True: 7, False: 56]
  ------------------
   46|      7|    return mrb->float_class;
   47|      0|#endif
   48|      0|  case MRB_TT_CPTR:
  ------------------
  |  Branch (48:3): [True: 0, False: 63]
  ------------------
   49|      0|    return mrb->object_class;
   50|      0|  default:
  ------------------
  |  Branch (50:3): [True: 0, False: 63]
  ------------------
   51|      0|    return NULL;
   52|     63|  }
   53|     63|}
vm.c:mrb_class:
   28|   780k|{
   29|   780k|  if (!mrb_immediate_p(v)) {
  ------------------
  |  |  148|   780k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  1.56M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 120k, False: 660k]
  |  |  |  Branch (148:63): [True: 3.76k, False: 656k]
  |  |  ------------------
  ------------------
   30|   656k|    return mrb_obj_ptr(v)->c;
  ------------------
  |  |   34|   656k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   656k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   31|   656k|  }
   32|       |
   33|   123k|  switch (mrb_type(v)) {
   34|  6.31k|  case MRB_TT_FALSE:
  ------------------
  |  Branch (34:3): [True: 6.31k, False: 117k]
  ------------------
   35|  6.31k|    if (mrb_fixnum(v))
  ------------------
  |  |  160|  6.31k|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|  6.31k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|  6.31k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:24): [True: 2.54k, False: 3.76k]
  |  |  ------------------
  ------------------
   36|  2.54k|      return mrb->false_class;
   37|  3.76k|    return mrb->nil_class;
   38|  2.49k|  case MRB_TT_TRUE:
  ------------------
  |  Branch (38:3): [True: 2.49k, False: 121k]
  ------------------
   39|  2.49k|    return mrb->true_class;
   40|      0|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (40:3): [True: 0, False: 123k]
  ------------------
   41|      0|    return mrb->symbol_class;
   42|   111k|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (42:3): [True: 111k, False: 12.8k]
  ------------------
   43|   111k|    return mrb->integer_class;
   44|      0|#ifndef MRB_NO_FLOAT
   45|  4.07k|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (45:3): [True: 4.07k, False: 119k]
  ------------------
   46|  4.07k|    return mrb->float_class;
   47|      0|#endif
   48|      0|  case MRB_TT_CPTR:
  ------------------
  |  Branch (48:3): [True: 0, False: 123k]
  ------------------
   49|      0|    return mrb->object_class;
   50|      0|  default:
  ------------------
  |  Branch (50:3): [True: 0, False: 123k]
  ------------------
   51|      0|    return NULL;
   52|   123k|  }
   53|   123k|}
class.c:mrb_class:
   28|      5|{
   29|      5|  if (!mrb_immediate_p(v)) {
  ------------------
  |  |  148|      5|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|     10|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 4, False: 1]
  |  |  |  Branch (148:63): [True: 0, False: 1]
  |  |  ------------------
  ------------------
   30|      1|    return mrb_obj_ptr(v)->c;
  ------------------
  |  |   34|      1|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      1|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   31|      1|  }
   32|       |
   33|      4|  switch (mrb_type(v)) {
   34|      0|  case MRB_TT_FALSE:
  ------------------
  |  Branch (34:3): [True: 0, False: 4]
  ------------------
   35|      0|    if (mrb_fixnum(v))
  ------------------
  |  |  160|      0|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|      0|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|      0|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   36|      0|      return mrb->false_class;
   37|      0|    return mrb->nil_class;
   38|      0|  case MRB_TT_TRUE:
  ------------------
  |  Branch (38:3): [True: 0, False: 4]
  ------------------
   39|      0|    return mrb->true_class;
   40|      0|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (40:3): [True: 0, False: 4]
  ------------------
   41|      0|    return mrb->symbol_class;
   42|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (42:3): [True: 0, False: 4]
  ------------------
   43|      0|    return mrb->integer_class;
   44|      0|#ifndef MRB_NO_FLOAT
   45|      4|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (45:3): [True: 4, False: 0]
  ------------------
   46|      4|    return mrb->float_class;
   47|      0|#endif
   48|      0|  case MRB_TT_CPTR:
  ------------------
  |  Branch (48:3): [True: 0, False: 4]
  ------------------
   49|      0|    return mrb->object_class;
   50|      0|  default:
  ------------------
  |  Branch (50:3): [True: 0, False: 4]
  ------------------
   51|      0|    return NULL;
   52|      4|  }
   53|      4|}
kernel.c:mrb_class:
   28|   977k|{
   29|   977k|  if (!mrb_immediate_p(v)) {
  ------------------
  |  |  148|   977k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  1.95M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 126, False: 976k]
  |  |  |  Branch (148:63): [True: 0, False: 976k]
  |  |  ------------------
  ------------------
   30|   976k|    return mrb_obj_ptr(v)->c;
  ------------------
  |  |   34|   976k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   976k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   31|   976k|  }
   32|       |
   33|    126|  switch (mrb_type(v)) {
   34|     63|  case MRB_TT_FALSE:
  ------------------
  |  Branch (34:3): [True: 63, False: 63]
  ------------------
   35|     63|    if (mrb_fixnum(v))
  ------------------
  |  |  160|     63|#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
  |  |  ------------------
  |  |  |  |   49|     63|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  ------------------
  |  |  |  |  |  |   48|     63|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:24): [True: 63, False: 0]
  |  |  ------------------
  ------------------
   36|     63|      return mrb->false_class;
   37|      0|    return mrb->nil_class;
   38|     63|  case MRB_TT_TRUE:
  ------------------
  |  Branch (38:3): [True: 63, False: 63]
  ------------------
   39|     63|    return mrb->true_class;
   40|      0|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (40:3): [True: 0, False: 126]
  ------------------
   41|      0|    return mrb->symbol_class;
   42|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (42:3): [True: 0, False: 126]
  ------------------
   43|      0|    return mrb->integer_class;
   44|      0|#ifndef MRB_NO_FLOAT
   45|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (45:3): [True: 0, False: 126]
  ------------------
   46|      0|    return mrb->float_class;
   47|      0|#endif
   48|      0|  case MRB_TT_CPTR:
  ------------------
  |  Branch (48:3): [True: 0, False: 126]
  ------------------
   49|      0|    return mrb->object_class;
   50|      0|  default:
  ------------------
  |  Branch (50:3): [True: 0, False: 126]
  ------------------
   51|      0|    return NULL;
   52|    126|  }
   53|    126|}

vm.c:bin_to_uint32:
  137|  5.23k|{
  138|  5.23k|  return (uint32_t)bin[0] << 24 |
  139|  5.23k|         (uint32_t)bin[1] << 16 |
  140|  5.23k|         (uint32_t)bin[2] << 8  |
  141|  5.23k|         (uint32_t)bin[3];
  142|  5.23k|}

vm.c:mrb_irep_catch_handler_table:
   76|  5.23k|{
   77|  5.23k|  if (irep->clen > 0) {
  ------------------
  |  Branch (77:7): [True: 5.23k, False: 0]
  ------------------
   78|  5.23k|    return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen);
   79|  5.23k|  }
   80|      0|  else {
   81|      0|    return (const struct mrb_irep_catch_handler*)NULL;
   82|      0|  }
   83|  5.23k|}

random.c:mrb_istruct_ptr:
   39|  3.49k|{
   40|  3.49k|  return ISTRUCT_PTR(object);
  ------------------
  |  |   31|  3.49k|#define ISTRUCT_PTR(obj)      (RISTRUCT(obj)->inline_data)
  |  |  ------------------
  |  |  |  |   30|  3.49k|#define RISTRUCT(obj)         ((struct RIStruct*)(mrb_ptr(obj)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  3.49k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   41|  3.49k|}

vm.c:mrb_int_add_overflow:
   74|  69.6k|{
   75|  69.6k|  return __builtin_add_overflow(augend, addend, sum);
   76|  69.6k|}
vm.c:mrb_int_sub_overflow:
   80|  5.18k|{
   81|  5.18k|  return __builtin_sub_overflow(minuend, subtrahend, difference);
   82|  5.18k|}
vm.c:mrb_int_mul_overflow:
   86|  4.35k|{
   87|  4.35k|  return __builtin_mul_overflow(multiplier, multiplicand, product);
   88|  4.35k|}
string.c:mrb_int_add_overflow:
   74|  32.5k|{
   75|  32.5k|  return __builtin_add_overflow(augend, addend, sum);
   76|  32.5k|}
string.c:mrb_int_mul_overflow:
   86|     21|{
   87|     21|  return __builtin_mul_overflow(multiplier, multiplicand, product);
   88|     21|}
codegen.c:mrb_int_add_overflow:
   74|  5.32k|{
   75|  5.32k|  return __builtin_add_overflow(augend, addend, sum);
   76|  5.32k|}
codegen.c:mrb_int_sub_overflow:
   80|  7.87k|{
   81|  7.87k|  return __builtin_sub_overflow(minuend, subtrahend, difference);
   82|  7.87k|}
codegen.c:mrb_int_mul_overflow:
   86|   667k|{
   87|   667k|  return __builtin_mul_overflow(multiplier, multiplicand, product);
   88|   667k|}

state.c:mrb_obj_value:
  368|  46.9k|{
  369|  46.9k|  mrb_value v;
  370|  46.9k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  46.9k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  46.9k|  return v;
  372|  46.9k|}
gc.c:mrb_nil_value:
  381|  32.9k|{
  382|  32.9k|  mrb_value v;
  383|  32.9k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  32.9k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  32.9k|  return v;
  385|  32.9k|}
symbol.c:mrb_ro_data_p:
  432|   158k|{
  433|   158k|  return &etext < p && p < &edata;
  ------------------
  |  Branch (433:10): [True: 158k, False: 0]
  |  Branch (433:24): [True: 0, False: 158k]
  ------------------
  434|   158k|}
array.c:mrb_obj_value:
  368|   280k|{
  369|   280k|  mrb_value v;
  370|   280k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|   280k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|   280k|  return v;
  372|   280k|}
array.c:mrb_nil_value:
  381|  7.96k|{
  382|  7.96k|  mrb_value v;
  383|  7.96k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  7.96k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  7.96k|  return v;
  385|  7.96k|}
array.c:mrb_int_value:
  345|  63.8k|{
  346|  63.8k|  mrb_value v;
  347|  63.8k|  SET_INT_VALUE(mrb, v, i);
  ------------------
  |  |  214|  63.8k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
  348|  63.8k|  return v;
  349|  63.8k|}
array.c:mrb_false_value:
  391|  24.8k|{
  392|  24.8k|  mrb_value v;
  393|  24.8k|  SET_FALSE_VALUE(v);
  ------------------
  |  |  211|  24.8k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  ------------------
  394|  24.8k|  return v;
  395|  24.8k|}
variable.c:mrb_nil_value:
  381|  12.0k|{
  382|  12.0k|  mrb_value v;
  383|  12.0k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  12.0k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  12.0k|  return v;
  385|  12.0k|}
variable.c:mrb_symbol_value:
  360|  3.49k|{
  361|  3.49k|  mrb_value v;
  362|  3.49k|  SET_SYM_VALUE(v, i);
  ------------------
  |  |  216|  3.49k|#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
  |  |  ------------------
  |  |  |  |   74|  3.49k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  363|  3.49k|  return v;
  364|  3.49k|}
hash.c:mrb_obj_value:
  368|  58.8k|{
  369|  58.8k|  mrb_value v;
  370|  58.8k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  58.8k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  58.8k|  return v;
  372|  58.8k|}
numeric.c:mrb_float_value:
  324|  7.30k|{
  325|  7.30k|  mrb_value v;
  326|  7.30k|  (void) mrb;
  327|  7.30k|  SET_FLOAT_VALUE(mrb, v, f);
  ------------------
  |  |  206|  7.30k|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
  328|  7.30k|  return v;
  329|  7.30k|}
numeric.c:mrb_int_value:
  345|  7.09k|{
  346|  7.09k|  mrb_value v;
  347|  7.09k|  SET_INT_VALUE(mrb, v, i);
  ------------------
  |  |  214|  7.09k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
  348|  7.09k|  return v;
  349|  7.09k|}
numeric.c:mrb_true_value:
  401|  1.02k|{
  402|  1.02k|  mrb_value v;
  403|  1.02k|  SET_TRUE_VALUE(v);
  ------------------
  |  |  212|  1.02k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  ------------------
  404|  1.02k|  return v;
  405|  1.02k|}
numeric.c:mrb_false_value:
  391|  4.58k|{
  392|  4.58k|  mrb_value v;
  393|  4.58k|  SET_FALSE_VALUE(v);
  ------------------
  |  |  211|  4.58k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  ------------------
  394|  4.58k|  return v;
  395|  4.58k|}
numeric.c:mrb_bool_value:
  409|  60.2k|{
  410|  60.2k|  mrb_value v;
  411|  60.2k|  SET_BOOL_VALUE(v, boolean);
  ------------------
  |  |  213|  60.2k|#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  212|    772|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  |               #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  211|  59.4k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  |  |  Branch (213:30): [True: 772, False: 59.4k]
  |  |  ------------------
  ------------------
  412|  60.2k|  return v;
  413|  60.2k|}
numeric.c:mrb_fixnum_value:
  352|    744|{
  353|    744|  mrb_value v;
  354|    744|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|    744|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|    744|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|    744|  return v;
  356|    744|}
numeric.c:mrb_obj_value:
  368|  1.74k|{
  369|  1.74k|  mrb_value v;
  370|  1.74k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  1.74k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  1.74k|  return v;
  372|  1.74k|}
object.c:mrb_bool_value:
  409|  1.52k|{
  410|  1.52k|  mrb_value v;
  411|  1.52k|  SET_BOOL_VALUE(v, boolean);
  ------------------
  |  |  213|  1.52k|#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  212|    546|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  |               #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  211|    982|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  |  |  Branch (213:30): [True: 546, False: 982]
  |  |  ------------------
  ------------------
  412|  1.52k|  return v;
  413|  1.52k|}
object.c:mrb_true_value:
  401|  1.59k|{
  402|  1.59k|  mrb_value v;
  403|  1.59k|  SET_TRUE_VALUE(v);
  ------------------
  |  |  212|  1.59k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  ------------------
  404|  1.59k|  return v;
  405|  1.59k|}
object.c:mrb_nil_value:
  381|    673|{
  382|    673|  mrb_value v;
  383|    673|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|    673|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|    673|  return v;
  385|    673|}
object.c:mrb_float_value:
  324|  6.24k|{
  325|  6.24k|  mrb_value v;
  326|  6.24k|  (void) mrb;
  327|  6.24k|  SET_FLOAT_VALUE(mrb, v, f);
  ------------------
  |  |  206|  6.24k|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
  328|  6.24k|  return v;
  329|  6.24k|}
error.c:mrb_obj_value:
  368|  4.20k|{
  369|  4.20k|  mrb_value v;
  370|  4.20k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  4.20k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  4.20k|  return v;
  372|  4.20k|}
error.c:mrb_int_value:
  345|    104|{
  346|    104|  mrb_value v;
  347|    104|  SET_INT_VALUE(mrb, v, i);
  ------------------
  |  |  214|    104|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
  348|    104|  return v;
  349|    104|}
error.c:mrb_float_value:
  324|      3|{
  325|      3|  mrb_value v;
  326|      3|  (void) mrb;
  327|      3|  SET_FLOAT_VALUE(mrb, v, f);
  ------------------
  |  |  206|      3|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
  328|      3|  return v;
  329|      3|}
error.c:mrb_symbol_value:
  360|    252|{
  361|    252|  mrb_value v;
  362|    252|  SET_SYM_VALUE(v, i);
  ------------------
  |  |  216|    252|#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
  |  |  ------------------
  |  |  |  |   74|    252|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  363|    252|  return v;
  364|    252|}
vm.c:mrb_obj_value:
  368|  1.84M|{
  369|  1.84M|  mrb_value v;
  370|  1.84M|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  1.84M|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  1.84M|  return v;
  372|  1.84M|}
vm.c:mrb_nil_value:
  381|   596k|{
  382|   596k|  mrb_value v;
  383|   596k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|   596k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|   596k|  return v;
  385|   596k|}
vm.c:mrb_int_value:
  345|    356|{
  346|    356|  mrb_value v;
  347|    356|  SET_INT_VALUE(mrb, v, i);
  ------------------
  |  |  214|    356|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
  348|    356|  return v;
  349|    356|}
vm.c:mrb_symbol_value:
  360|   809k|{
  361|   809k|  mrb_value v;
  362|   809k|  SET_SYM_VALUE(v, i);
  ------------------
  |  |  216|   809k|#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
  |  |  ------------------
  |  |  |  |   74|   809k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  363|   809k|  return v;
  364|   809k|}
class.c:mrb_symbol_value:
  360|   171k|{
  361|   171k|  mrb_value v;
  362|   171k|  SET_SYM_VALUE(v, i);
  ------------------
  |  |  216|   171k|#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
  |  |  ------------------
  |  |  |  |   74|   171k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  363|   171k|  return v;
  364|   171k|}
class.c:mrb_obj_value:
  368|  1.64M|{
  369|  1.64M|  mrb_value v;
  370|  1.64M|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  1.64M|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  1.64M|  return v;
  372|  1.64M|}
class.c:mrb_nil_value:
  381|   213k|{
  382|   213k|  mrb_value v;
  383|   213k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|   213k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|   213k|  return v;
  385|   213k|}
class.c:mrb_bool_value:
  409|  6.17k|{
  410|  6.17k|  mrb_value v;
  411|  6.17k|  SET_BOOL_VALUE(v, boolean);
  ------------------
  |  |  213|  6.17k|#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  212|  4.71k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  |               #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  211|  1.46k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  |  |  Branch (213:30): [True: 4.71k, False: 1.46k]
  |  |  ------------------
  ------------------
  412|  6.17k|  return v;
  413|  6.17k|}
string.c:mrb_obj_value:
  368|   403k|{
  369|   403k|  mrb_value v;
  370|   403k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|   403k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|   403k|  return v;
  372|   403k|}
string.c:mrb_ro_data_p:
  432|  3.69k|{
  433|  3.69k|  return &etext < p && p < &edata;
  ------------------
  |  Branch (433:10): [True: 3.69k, False: 0]
  |  Branch (433:24): [True: 0, False: 3.69k]
  ------------------
  434|  3.69k|}
kernel.c:mrb_false_value:
  391|  1.59k|{
  392|  1.59k|  mrb_value v;
  393|  1.59k|  SET_FALSE_VALUE(v);
  ------------------
  |  |  211|  1.59k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  ------------------
  394|  1.59k|  return v;
  395|  1.59k|}
kernel.c:mrb_bool_value:
  409|  40.8k|{
  410|  40.8k|  mrb_value v;
  411|  40.8k|  SET_BOOL_VALUE(v, boolean);
  ------------------
  |  |  213|  40.8k|#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  212|  11.3k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  |               #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
  |  |  ------------------
  |  |  |  |  211|  29.5k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  |  |  Branch (213:30): [True: 11.3k, False: 29.5k]
  |  |  ------------------
  ------------------
  412|  40.8k|  return v;
  413|  40.8k|}
bigint.c:mrb_obj_value:
  368|  50.8k|{
  369|  50.8k|  mrb_value v;
  370|  50.8k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  50.8k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  50.8k|  return v;
  372|  50.8k|}
bigint.c:mrb_float_value:
  324|    659|{
  325|    659|  mrb_value v;
  326|    659|  (void) mrb;
  327|    659|  SET_FLOAT_VALUE(mrb, v, f);
  ------------------
  |  |  206|    659|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
  328|    659|  return v;
  329|    659|}
bigint.c:mrb_int_value:
  345|  7.18k|{
  346|  7.18k|  mrb_value v;
  347|  7.18k|  SET_INT_VALUE(mrb, v, i);
  ------------------
  |  |  214|  7.18k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
  348|  7.18k|  return v;
  349|  7.18k|}
y.tab.c:mrb_undef_value:
  417|    203|{
  418|    203|  mrb_value v;
  419|    203|  SET_UNDEF_VALUE(v);
  ------------------
  |  |  209|    203|#define SET_UNDEF_VALUE(r) ((r).w = MRB_Qundef)
  ------------------
  420|    203|  return v;
  421|    203|}
y.tab.c:mrb_nil_value:
  381|    443|{
  382|    443|  mrb_value v;
  383|    443|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|    443|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|    443|  return v;
  385|    443|}
gem_init.c:mrb_nil_value:
  381|  1.74k|{
  382|  1.74k|  mrb_value v;
  383|  1.74k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  1.74k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  1.74k|  return v;
  385|  1.74k|}
etc.c:mrb_fixnum_value:
  352|   398k|{
  353|   398k|  mrb_value v;
  354|   398k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|   398k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|   398k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|   398k|  return v;
  356|   398k|}
version.c:mrb_fixnum_value:
  352|  1.74k|{
  353|  1.74k|  mrb_value v;
  354|  1.74k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|  1.74k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  1.74k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|  1.74k|  return v;
  356|  1.74k|}
codegen.c:mrb_ro_data_p:
  432|  18.5k|{
  433|  18.5k|  return &etext < p && p < &edata;
  ------------------
  |  Branch (433:10): [True: 18.5k, False: 0]
  |  Branch (433:24): [True: 0, False: 18.5k]
  ------------------
  434|  18.5k|}
numeric_ext.c:mrb_fixnum_value:
  352|  12.2k|{
  353|  12.2k|  mrb_value v;
  354|  12.2k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|  12.2k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  12.2k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|  12.2k|  return v;
  356|  12.2k|}
numeric_ext.c:mrb_float_value:
  324|  5.23k|{
  325|  5.23k|  mrb_value v;
  326|  5.23k|  (void) mrb;
  327|  5.23k|  SET_FLOAT_VALUE(mrb, v, f);
  ------------------
  |  |  206|  5.23k|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
  328|  5.23k|  return v;
  329|  5.23k|}
mruby_objectspace.c:mrb_symbol_value:
  360|   390k|{
  361|   390k|  mrb_value v;
  362|   390k|  SET_SYM_VALUE(v, i);
  ------------------
  |  |  216|   390k|#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
  |  |  ------------------
  |  |  |  |   74|   390k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  363|   390k|  return v;
  364|   390k|}
mruby_objectspace.c:mrb_fixnum_value:
  352|   300k|{
  353|   300k|  mrb_value v;
  354|   300k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|   300k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|   300k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|   300k|  return v;
  356|   300k|}
time.c:mrb_obj_value:
  368|  7.54k|{
  369|  7.54k|  mrb_value v;
  370|  7.54k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  7.54k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  7.54k|  return v;
  372|  7.54k|}
time.c:mrb_fixnum_value:
  352|  3.76k|{
  353|  3.76k|  mrb_value v;
  354|  3.76k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|  3.76k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  3.76k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|  3.76k|  return v;
  356|  3.76k|}
random.c:mrb_obj_value:
  368|  5.23k|{
  369|  5.23k|  mrb_value v;
  370|  5.23k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  5.23k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  5.23k|  return v;
  372|  5.23k|}
io.c:mrb_nil_value:
  381|  5.23k|{
  382|  5.23k|  mrb_value v;
  383|  5.23k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  5.23k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  5.23k|  return v;
  385|  5.23k|}
io.c:mrb_fixnum_value:
  352|  5.23k|{
  353|  5.23k|  mrb_value v;
  354|  5.23k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|  5.23k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  5.23k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|  5.23k|  return v;
  356|  5.23k|}
file.c:mrb_fixnum_value:
  352|  38.3k|{
  353|  38.3k|  mrb_value v;
  354|  38.3k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|  38.3k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  38.3k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|  38.3k|  return v;
  356|  38.3k|}
file.c:mrb_nil_value:
  381|  1.74k|{
  382|  1.74k|  mrb_value v;
  383|  1.74k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  1.74k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  1.74k|  return v;
  385|  1.74k|}
socket.c:mrb_nil_value:
  381|  1.74k|{
  382|  1.74k|  mrb_value v;
  383|  1.74k|  SET_NIL_VALUE(v);
  ------------------
  |  |  210|  1.74k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  384|  1.74k|  return v;
  385|  1.74k|}
socket.c:mrb_int_value:
  345|   247k|{
  346|   247k|  mrb_value v;
  347|   247k|  SET_INT_VALUE(mrb, v, i);
  ------------------
  |  |  214|   247k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
  348|   247k|  return v;
  349|   247k|}
errno.c:mrb_obj_value:
  368|  1.74k|{
  369|  1.74k|  mrb_value v;
  370|  1.74k|  SET_OBJ_VALUE(v, (struct RBasic*)p);
  ------------------
  |  |  217|  1.74k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  371|  1.74k|  return v;
  372|  1.74k|}
errno.c:mrb_fixnum_value:
  352|  3.49k|{
  353|  3.49k|  mrb_value v;
  354|  3.49k|  SET_FIXNUM_VALUE(v, i);
  ------------------
  |  |  215|  3.49k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  3.49k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  355|  3.49k|  return v;
  356|  3.49k|}
math.c:mrb_float_value:
  324|  9.80k|{
  325|  9.80k|  mrb_value v;
  326|  9.80k|  (void) mrb;
  327|  9.80k|  SET_FLOAT_VALUE(mrb, v, f);
  ------------------
  |  |  206|  9.80k|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
  328|  9.80k|  return v;
  329|  9.80k|}

mrb_mruby_array_ext_gem_init:
  346|  1.74k|{
  347|  1.74k|  struct RClass * a = mrb->array_class;
  348|       |
  349|  1.74k|  mrb_define_method(mrb, a, "assoc",  ary_assoc,  MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  350|  1.74k|  mrb_define_method(mrb, a, "at",     ary_at,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  351|  1.74k|  mrb_define_method(mrb, a, "rassoc", ary_rassoc, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  352|  1.74k|  mrb_define_method(mrb, a, "values_at", ary_values_at, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  353|  1.74k|  mrb_define_method(mrb, a, "slice!", ary_slice_bang, MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  354|  1.74k|  mrb_define_method(mrb, a, "compact", ary_compact, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  355|  1.74k|  mrb_define_method(mrb, a, "compact!", ary_compact_bang, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  356|  1.74k|  mrb_define_method(mrb, a, "rotate", ary_rotate, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  357|  1.74k|  mrb_define_method(mrb, a, "rotate!", ary_rotate_bang, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  358|  1.74k|}
mrb_mruby_array_ext_gem_final:
  362|  1.74k|{
  363|  1.74k|}
array.c:ary_assoc:
   31|    327|{
   32|    327|  mrb_int i;
   33|    327|  mrb_value v;
   34|    327|  mrb_value k = mrb_get_arg1(mrb);
   35|       |
   36|  1.00k|  for (i = 0; i < RARRAY_LEN(ary); i++) {
  ------------------
  |  |   72|  1.00k|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|  1.00k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  1.00k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  1.00k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 639, False: 361]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|    639|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    639|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (36:15): [True: 673, False: 327]
  ------------------
   37|    673|    v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
  ------------------
  |  |   73|    673|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|    673|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    673|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    673|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 329, False: 344]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|    329|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   38|    673|    if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
  ------------------
  |  |  174|  1.34k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
                  if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
  ------------------
  |  |   72|      0|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (38:9): [True: 0, False: 673]
  |  Branch (38:26): [True: 0, False: 0]
  ------------------
   39|    673|        mrb_equal(mrb, RARRAY_PTR(v)[0], k))
  ------------------
  |  |   73|      0|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (39:9): [True: 0, False: 0]
  ------------------
   40|      0|      return v;
   41|    673|  }
   42|    327|  return mrb_nil_value();
   43|    327|}
array.c:ary_rassoc:
   61|    258|{
   62|    258|  mrb_int i;
   63|    258|  mrb_value v;
   64|    258|  mrb_value value = mrb_get_arg1(mrb);
   65|       |
   66|    898|  for (i = 0; i < RARRAY_LEN(ary); i++) {
  ------------------
  |  |   72|    898|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|    898|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    898|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    898|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 608, False: 290]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|    608|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    608|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (66:15): [True: 640, False: 258]
  ------------------
   67|    640|    v = RARRAY_PTR(ary)[i];
  ------------------
  |  |   73|    640|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|    640|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    640|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    640|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 357, False: 283]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|    357|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   68|    640|    if (mrb_array_p(v) &&
  ------------------
  |  |  186|    640|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|  1.28k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  1.28k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  1.28k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 640, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   69|    640|        RARRAY_LEN(v) > 1 &&
  ------------------
  |  |   72|      0|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (69:9): [True: 0, False: 0]
  ------------------
   70|    640|        mrb_equal(mrb, RARRAY_PTR(v)[1], value))
  ------------------
  |  |   73|      0|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (70:9): [True: 0, False: 0]
  ------------------
   71|      0|      return v;
   72|    640|  }
   73|    258|  return mrb_nil_value();
   74|    258|}
array.c:ary_values_at:
  105|    276|{
  106|    276|  mrb_int argc = mrb_get_argc(mrb);
  107|    276|  const mrb_value *argv = mrb_get_argv(mrb);
  108|       |
  109|    276|  return mrb_get_values_at(mrb, self, RARRAY_LEN(self), argc, argv, ary_ref);
  ------------------
  |  |   72|    276|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|    276|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    276|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    276|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 273, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|    273|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    273|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  110|    276|}
array.c:ary_ref:
   99|    274|{
  100|    274|  return mrb_ary_entry(ary, n);
  101|    274|}
array.c:ary_rotate:
  253|    479|{
  254|    479|  mrb_int count=1;
  255|    479|  mrb_get_args(mrb, "|i", &count);
  256|       |
  257|    479|  mrb_value ary = mrb_ary_new(mrb);
  258|    479|  mrb_int len = RARRAY_LEN(self);
  ------------------
  |  |   72|    479|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|    479|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    479|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    479|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 457, False: 22]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|    457|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    457|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  259|    479|  mrb_value *p = RARRAY_PTR(self);
  ------------------
  |  |   73|    479|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|    479|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|    479|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    479|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 457, False: 22]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|    457|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  260|    479|  mrb_int idx;
  261|       |
  262|    479|  if (len <= 0) return ary;
  ------------------
  |  Branch (262:7): [True: 0, False: 479]
  ------------------
  263|    479|  if (count < 0) {
  ------------------
  |  Branch (263:7): [True: 96, False: 383]
  ------------------
  264|     96|    idx = len - (~count % len) - 1;
  265|     96|  }
  266|    383|  else {
  267|    383|    idx = count % len;
  268|    383|  }
  269|  1.02k|  for (mrb_int i = 0; i<len; i++) {
  ------------------
  |  Branch (269:23): [True: 549, False: 479]
  ------------------
  270|    549|    mrb_ary_push(mrb, ary, p[idx++]);
  271|    549|    if (idx == len) idx = 0;
  ------------------
  |  Branch (271:9): [True: 479, False: 70]
  ------------------
  272|    549|  }
  273|    479|  return ary;
  274|    479|}
array.c:ary_rotate_bang:
  304|    697|{
  305|    697|  mrb_int count=1;
  306|    697|  mrb_get_args(mrb, "|i", &count);
  307|       |
  308|    697|  struct RArray *a = mrb_ary_ptr(self);
  ------------------
  |  |   51|    697|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|    697|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  309|    697|  mrb_int len = ARY_LEN(a);
  ------------------
  |  |   70|    697|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|    697|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    697|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 508, False: 189]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|    508|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    508|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  310|    697|  mrb_value *p = ARY_PTR(a);
  ------------------
  |  |   71|    697|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|    697|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    697|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 508, False: 189]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|    508|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  311|    697|  mrb_int idx;
  312|       |
  313|    697|  mrb_ary_modify(mrb, a);
  314|    697|  if (len == 0 || count == 0) return self;
  ------------------
  |  Branch (314:7): [True: 0, False: 697]
  |  Branch (314:19): [True: 46, False: 651]
  ------------------
  315|    651|  if (count == 1) {
  ------------------
  |  Branch (315:7): [True: 523, False: 128]
  ------------------
  316|    523|    mrb_value v = p[0];
  317|  5.76k|    for (mrb_int i=1; i<len; i++) {
  ------------------
  |  Branch (317:23): [True: 5.24k, False: 523]
  ------------------
  318|  5.24k|      p[i-1] = p[i];
  319|  5.24k|    }
  320|    523|    p[len-1] = v;
  321|    523|    return self;
  322|    523|  }
  323|    128|  if (count < 0) {
  ------------------
  |  Branch (323:7): [True: 76, False: 52]
  ------------------
  324|     76|    idx = len - (~count % len) - 1;
  325|     76|  }
  326|     52|  else {
  327|     52|    idx = count % len;
  328|     52|  }
  329|       |  /* e.g. [1,2,3,4,5].rotate!(2) -> [3,4,5,1,2] */
  330|       |  /* first, reverse the whole array */
  331|       |  /* [1,2,3,4,5] -> [5,4,3,2,1] */
  332|    128|  rev(p, 0, len);
  333|       |  /* then, re-reverse part before idx */
  334|       |  /* [5,4,3,2,1] -> [3,4,5,2,1] */
  335|       |  /*        ^idx     ~~~~~      */
  336|    128|  rev(p, 0, len-idx);
  337|       |  /* finally, re-reverse part after idx */
  338|       |  /* [3,4,5,2,1] -> [3,4,5,1,2] */
  339|       |  /*        ^idx           ~~~  */
  340|    128|  rev(p, len-idx, len);
  341|    128|  return self;
  342|    651|}
array.c:rev:
  278|    384|{
  279|  1.38k|  for (mrb_int i=beg,j=end-1; i<j; i++,j--) {
  ------------------
  |  Branch (279:31): [True: 1.00k, False: 384]
  ------------------
  280|  1.00k|    mrb_value v = p[i];
  281|  1.00k|    p[i] = p[j];
  282|  1.00k|    p[j] = v;
  283|  1.00k|  }
  284|    384|}

mrb_bint_new_int:
 1034|  18.3k|{
 1035|  18.3k|  struct RBigint *b = bint_new_int(mrb, x);
 1036|  18.3k|  return mrb_obj_value(b);
 1037|  18.3k|}
mrb_gc_free_bint:
 1089|  48.1k|{
 1090|  48.1k|  struct RBigint *b = (struct RBigint*)x;
 1091|  48.1k|  mpz_clear(mrb, &b->mp);
 1092|  48.1k|}
mrb_bint_new_float:
 1097|     12|{
 1098|       |  /* x should not be NaN nor Infinity */
 1099|     12|  mrb_assert(x == x && x != x * 0.5);
  ------------------
  |  |   68|     12|#define mrb_assert(p) ((void)0)
  ------------------
 1100|       |
 1101|     12|  int sn;
 1102|     12|  if (x < 0.0) {
  ------------------
  |  Branch (1102:7): [True: 10, False: 2]
  ------------------
 1103|     10|    x = -x;
 1104|     10|    sn = -1;
 1105|     10|  }
 1106|      2|  else {
 1107|      2|    sn = 1;
 1108|      2|  }
 1109|     12|  if (x < 1.0) {
  ------------------
  |  Branch (1109:7): [True: 0, False: 12]
  ------------------
 1110|      0|    return mrb_fixnum_value(0);
 1111|      0|  }
 1112|       |
 1113|     12|  struct RBigint *bint = bint_new(mrb);
 1114|     12|  mpz_t *r = &bint->mp;
 1115|     12|  r->sn = sn;
 1116|       |
 1117|     12|  mrb_float b = (double)DIG_BASE;
  ------------------
  |  |   17|     12|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|     12|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|     12|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1118|     12|  mrb_float bi = 1.0 / b;
 1119|     12|  size_t rn;
 1120|     12|  mp_limb *rp;
 1121|     12|  mp_limb f;
 1122|       |
 1123|     63|  for (rn = 1; x >= b; rn++)
  ------------------
  |  Branch (1123:16): [True: 51, False: 12]
  ------------------
 1124|     51|    x *= bi;
 1125|       |
 1126|     12|  mpz_realloc(mrb, r, rn);
 1127|     12|  rp = r->p;
 1128|     63|  for (size_t i=rn-1;;i--) {
 1129|     63|    f = LOW((mp_limb)x);
  ------------------
  |  |   20|     63|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|     63|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|     63|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|     63|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|     63|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1130|     63|    x -= f;
 1131|     63|    mrb_assert(x < 1.0);
  ------------------
  |  |   68|     63|#define mrb_assert(p) ((void)0)
  ------------------
 1132|     63|    rp[i] = f;
 1133|     63|    if (i == 0) break;
  ------------------
  |  Branch (1133:9): [True: 12, False: 51]
  ------------------
 1134|     63|  }
 1135|     12|  return bint_norm(mrb, bint);
 1136|     12|}
mrb_bint_as_float:
 1140|  3.20k|{
 1141|  3.20k|  struct RBigint *b = RBIGINT(self);
  ------------------
  |  |   59|  3.20k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  3.20k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1142|  3.20k|  mpz_t *i = &b->mp;
 1143|  3.20k|  mp_limb *d = i->p + i->sz;
 1144|  3.20k|  mrb_float val = 0;
 1145|       |
 1146|   176M|  while (d-- > i->p) {
  ------------------
  |  Branch (1146:10): [True: 176M, False: 3.20k]
  ------------------
 1147|   176M|    val = val * DIG_BASE + *d;
  ------------------
  |  |   17|   176M|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|   176M|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|   176M|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1148|   176M|  }
 1149|       |
 1150|  3.20k|  if (i->sn < 0) {
  ------------------
  |  Branch (1150:7): [True: 1.13k, False: 2.07k]
  ------------------
 1151|  1.13k|    val = -val;
 1152|  1.13k|  }
 1153|  3.20k|  return val;
 1154|  3.20k|}
mrb_as_bint:
 1159|  22.0k|{
 1160|  22.0k|  if (mrb_bigint_p(x)) return x;
  ------------------
  |  |  314|  22.0k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 10.8k, False: 11.2k]
  |  |  ------------------
  ------------------
 1161|  11.2k|  return mrb_bint_new_int(mrb, mrb_as_int(mrb, x));
  ------------------
  |  | 1425|  11.2k|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|  11.2k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
 1162|  22.0k|}
mrb_bint_as_int:
 1166|     41|{
 1167|     41|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|     41|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|     41|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1168|     41|  mrb_int i;
 1169|       |
 1170|     41|  if (!mpz_get_int(&b->mp, &i)) {
  ------------------
  |  Branch (1170:7): [True: 41, False: 0]
  ------------------
 1171|     41|    mrb_raise(mrb, E_RANGE_ERROR, "integer out of range");
  ------------------
  |  | 1379|     41|#define E_RANGE_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(RangeError))
  |  |  ------------------
  |  |  |  | 1371|     41|#define MRB_ERROR_SYM(sym) mrb_intern_lit(mrb, #sym)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1164|     41|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1075|     41|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1172|     41|  }
 1173|      0|  return i;
 1174|     41|}
mrb_bint_add_d:
 1222|  4.89k|{
 1223|  4.89k|  y = mrb_as_bint(mrb, y);
 1224|  4.89k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  4.89k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  4.89k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1225|  4.89k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  4.89k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  4.89k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1226|  4.89k|  struct RBigint *b3 = bint_new(mrb);
 1227|  4.89k|  mpz_add(mrb, &b3->mp, &b->mp, &b2->mp);
 1228|  4.89k|  return mrb_obj_value(b3);
 1229|  4.89k|}
mrb_bint_add:
 1233|  5.00k|{
 1234|  5.00k|#ifndef MRB_NO_FLOAT
 1235|  5.00k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  5.00k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  5.00k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 118, False: 4.89k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1236|    118|    mrb_float v1 = mrb_bint_as_float(mrb, x);
 1237|    118|    mrb_float v2 = mrb_float(y);
  ------------------
  |  |  155|    118|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1238|    118|    return mrb_float_value(mrb,v1+v2);
 1239|    118|  }
 1240|  4.89k|#endif
 1241|  4.89k|  x = mrb_bint_add_d(mrb, x, y);
 1242|  4.89k|  return bint_norm(mrb, RBIGINT(x));
  ------------------
  |  |   59|  4.89k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  4.89k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1243|  5.00k|}
mrb_bint_sub_d:
 1248|  4.96k|{
 1249|  4.96k|  y = mrb_as_bint(mrb, y);
 1250|  4.96k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  4.96k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  4.96k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1251|  4.96k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  4.96k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  4.96k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1252|  4.96k|  struct RBigint *b3 = bint_new(mrb);
 1253|  4.96k|  mpz_sub(mrb, &b3->mp, &b->mp, &b2->mp);
 1254|  4.96k|  return mrb_obj_value(b3);
 1255|  4.96k|}
mrb_bint_sub:
 1259|  5.10k|{
 1260|  5.10k|#ifndef MRB_NO_FLOAT
 1261|  5.10k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  5.10k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  5.10k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 143, False: 4.96k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1262|    143|    mrb_float v1 = mrb_bint_as_float(mrb, x);
 1263|    143|    mrb_float v2 = mrb_float(y);
  ------------------
  |  |  155|    143|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1264|    143|    return mrb_float_value(mrb,v1-v2);
 1265|    143|  }
 1266|  4.96k|#endif
 1267|  4.96k|  x = mrb_bint_sub_d(mrb, x, y);
 1268|  4.96k|  return bint_norm(mrb, RBIGINT(x));
  ------------------
  |  |   59|  4.96k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  4.96k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1269|  5.10k|}
mrb_bint_mul:
 1273|  2.65k|{
 1274|  2.65k|#ifndef MRB_NO_FLOAT
 1275|  2.65k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  2.65k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  2.65k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 117, False: 2.54k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1276|    117|    mrb_float v1 = mrb_bint_as_float(mrb, x);
 1277|    117|    mrb_float v2 = mrb_float(y);
  ------------------
  |  |  155|    117|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1278|    117|    return mrb_float_value(mrb,v1*v2);
 1279|    117|  }
 1280|  2.54k|#endif
 1281|  2.54k|  y = mrb_as_bint(mrb, y);
 1282|  2.54k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  2.54k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  2.54k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1283|  2.54k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  2.54k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  2.54k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1284|  2.54k|  struct RBigint *b3 = bint_new(mrb);
 1285|  2.54k|  mpz_mul(mrb, &b3->mp, &b->mp, &b2->mp);
 1286|  2.54k|  return bint_norm(mrb, b3);
 1287|  2.65k|}
mrb_bint_div:
 1291|  3.75k|{
 1292|  3.75k|#ifndef MRB_NO_FLOAT
 1293|  3.75k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  3.75k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  3.75k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 131, False: 3.62k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1294|    131|    mrb_float v1 = mrb_bint_as_float(mrb, x);
 1295|    131|    mrb_float v2 = mrb_float(y);
  ------------------
  |  |  155|    131|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1296|    131|    return mrb_float_value(mrb,v1*v2);
 1297|    131|  }
 1298|  3.62k|#endif
 1299|  3.62k|  if (mrb_integer_p(y) && mrb_integer(y) == 0) {
  ------------------
  |  |  171|  7.24k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  7.24k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 1.14k, False: 2.48k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  2.48k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  4.96k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  4.96k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 2.48k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 2.48k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 108, False: 2.37k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (mrb_integer_p(y) && mrb_integer(y) == 0) {
  ------------------
  |  |  166|  1.25k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  |  Branch (1299:27): [True: 1, False: 1.24k]
  ------------------
 1300|      1|    mrb_int_zerodiv(mrb);
 1301|      1|  }
 1302|  3.62k|  y = mrb_as_bint(mrb, y);
 1303|  3.62k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  3.62k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  3.62k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1304|  3.62k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  3.62k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  3.62k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1305|  3.62k|  struct RBigint *b3 = bint_new(mrb);
 1306|  3.62k|  if (b2->mp.sn == 0 || uzero(&b2->mp)) {
  ------------------
  |  Branch (1306:7): [True: 0, False: 3.62k]
  |  Branch (1306:25): [True: 0, False: 3.62k]
  ------------------
 1307|      0|    mrb_int_zerodiv(mrb);
 1308|      0|  }
 1309|  3.62k|  mpz_mdiv(mrb, &b3->mp, &b->mp, &b2->mp);
 1310|  3.62k|  return bint_norm(mrb, b3);
 1311|  3.62k|}
mrb_bint_add_ii:
 1315|  1.43k|{
 1316|  1.43k|  struct RBigint *b = bint_new(mrb);
 1317|  1.43k|  mpz_t z1, z2;
 1318|       |
 1319|  1.43k|  mpz_init_set_int(mrb, &z1, x);
 1320|  1.43k|  mpz_init_set_int(mrb, &z2, y);
 1321|  1.43k|  mpz_add(mrb, &b->mp, &z1, &z2);
 1322|  1.43k|  mpz_clear(mrb, &z1);
 1323|  1.43k|  mpz_clear(mrb, &z2);
 1324|  1.43k|  return bint_norm(mrb, b);
 1325|  1.43k|}
mrb_bint_sub_ii:
 1329|  1.28k|{
 1330|  1.28k|  struct RBigint *b = bint_new(mrb);
 1331|  1.28k|  mpz_t z1, z2;
 1332|       |
 1333|  1.28k|  mpz_init_set_int(mrb, &z1, x);
 1334|  1.28k|  mpz_init_set_int(mrb, &z2, y);
 1335|  1.28k|  mpz_sub(mrb, &b->mp, &z1, &z2);
 1336|  1.28k|  mpz_clear(mrb, &z1);
 1337|  1.28k|  mpz_clear(mrb, &z2);
 1338|  1.28k|  return bint_norm(mrb, b);
 1339|  1.28k|}
mrb_bint_mul_ii:
 1343|  1.78k|{
 1344|  1.78k|  struct RBigint *b = bint_new(mrb);
 1345|  1.78k|  mpz_t z1, z2;
 1346|       |
 1347|  1.78k|  mpz_init_set_int(mrb, &z1, x);
 1348|  1.78k|  mpz_init_set_int(mrb, &z2, y);
 1349|  1.78k|  mpz_mul(mrb, &b->mp, &z1, &z2);
 1350|  1.78k|  mpz_clear(mrb, &z1);
 1351|  1.78k|  mpz_clear(mrb, &z2);
 1352|  1.78k|  return bint_norm(mrb, b);
 1353|  1.78k|}
mrb_bint_mod:
 1357|  2.61k|{
 1358|  2.61k|#ifndef MRB_NO_FLOAT
 1359|  2.61k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  2.61k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  2.61k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 150, False: 2.46k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1360|    150|    mrb_float v1 = mrb_bint_as_float(mrb, x);
 1361|    150|    mrb_float v2 = mrb_float(y);
  ------------------
  |  |  155|    150|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1362|    150|    return mrb_float_value(mrb, fmod(v1, v2));
 1363|    150|  }
 1364|  2.46k|#endif
 1365|  2.46k|  if (mrb_integer_p(y) && mrb_integer(y) == 0) {
  ------------------
  |  |  171|  4.92k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  4.92k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 602, False: 1.86k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  1.86k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.72k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.72k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 5, False: 1.85k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.85k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 736, False: 1.11k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (mrb_integer_p(y) && mrb_integer(y) == 0) {
  ------------------
  |  |  166|  1.33k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  |  Branch (1365:27): [True: 4, False: 1.33k]
  ------------------
 1366|      4|    mrb_int_zerodiv(mrb);
 1367|      4|  }
 1368|  2.45k|  y = mrb_as_bint(mrb, y);
 1369|  2.45k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  2.45k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  2.45k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1370|  2.45k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  2.45k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  2.45k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1371|  2.45k|  struct RBigint *b3 = bint_new(mrb);
 1372|  2.45k|  if (b2->mp.sn == 0 || uzero(&b2->mp)) {
  ------------------
  |  Branch (1372:7): [True: 5, False: 2.45k]
  |  Branch (1372:25): [True: 0, False: 2.45k]
  ------------------
 1373|      0|    mrb_int_zerodiv(mrb);
 1374|      0|  }
 1375|  2.45k|  mpz_mmod(mrb, &b3->mp, &b->mp, &b2->mp);
 1376|  2.45k|  return bint_norm(mrb, b3);
 1377|  2.45k|}
mrb_bint_cmp:
 1422|  3.58k|{
 1423|  3.58k|#ifndef MRB_NO_FLOAT
 1424|  3.58k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  3.58k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  3.58k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 531, False: 3.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1425|    531|    mrb_float v1 = mrb_bint_as_float(mrb, x);
 1426|    531|    mrb_float v2 = mrb_float(y);
  ------------------
  |  |  155|    531|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1427|    531|    if (v1 == v2) return 0;
  ------------------
  |  Branch (1427:9): [True: 130, False: 401]
  ------------------
 1428|    401|    if (v1 > v2)  return 1;
  ------------------
  |  Branch (1428:9): [True: 160, False: 241]
  ------------------
 1429|    241|    return -1;
 1430|    401|  }
 1431|  3.04k|#endif
 1432|  3.04k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  3.04k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  3.04k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1433|  3.04k|  if (!mrb_bigint_p(y)) {
  ------------------
  |  |  314|  3.04k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  ------------------
  |  Branch (1433:7): [True: 1.12k, False: 1.92k]
  ------------------
 1434|  1.12k|    if (!mrb_integer_p(y)) return -2; /* type mismatch */
  ------------------
  |  |  171|  1.12k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  2.24k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 848, False: 275]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|    275|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|    550|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|    550|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 5, False: 270]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 270]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 270, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1435|       |
 1436|  1.11k|    mrb_int i1, i2 = mrb_integer(y);
  ------------------
  |  |  166|  1.11k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1437|  1.11k|    if (mpz_get_int(&b->mp, &i1)) {
  ------------------
  |  Branch (1437:9): [True: 0, False: 1.11k]
  ------------------
 1438|      0|      if (i1 == i2) return 0;
  ------------------
  |  Branch (1438:11): [True: 0, False: 0]
  ------------------
 1439|      0|      if (i1 > i2) return 1;
  ------------------
  |  Branch (1439:11): [True: 0, False: 0]
  ------------------
 1440|      0|      return -1;
 1441|      0|    }
 1442|  1.11k|    if (b->mp.sn > 0) return 1;
  ------------------
  |  Branch (1442:9): [True: 961, False: 157]
  ------------------
 1443|    157|    return -1;
 1444|  1.11k|  }
 1445|  1.92k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  1.92k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  1.92k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1446|  1.92k|  return mpz_cmp(mrb, &b->mp, &b2->mp);
 1447|  3.04k|}
mrb_bint_to_s:
 1503|      1|{
 1504|      1|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|      1|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|      1|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1505|       |
 1506|      1|  if (b->mp.sz == 0) return mrb_str_new_lit(mrb, "0");
  ------------------
  |  | 1209|      0|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  |  Branch (1506:7): [True: 0, False: 1]
  ------------------
 1507|       |
 1508|      1|  size_t len = mpz_sizeinbase(&b->mp, (int)base);
 1509|      1|  if (MRB_INT_MAX-2 < len) {
  ------------------
  |  |   82|      1|# define MRB_INT_MAX INT64_MAX
  ------------------
  |  Branch (1509:7): [True: 0, False: 1]
  ------------------
 1510|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "too long string from Integer");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  | 1371|      0|#define MRB_ERROR_SYM(sym) mrb_intern_lit(mrb, #sym)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1164|      0|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1511|      0|  }
 1512|      1|  mrb_value str = mrb_str_new(mrb, NULL, len+2);
 1513|      1|  mpz_get_str(mrb, RSTRING_PTR(str), len, base, &b->mp);
  ------------------
  |  |  100|      1|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|      1|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|      1|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|      1|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1514|      1|  RSTR_SET_LEN(RSTRING(str), strlen(RSTRING_PTR(str)));
  ------------------
  |  |   52|      1|#define RSTR_SET_LEN(s, n) do {\
  |  |   53|      1|  if (RSTR_EMBED_P(s)) {\
  |  |  ------------------
  |  |  |  |   44|      1|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      1|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:25): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|    RSTR_SET_EMBED_LEN((s),(n));\
  |  |  ------------------
  |  |  |  |   47|      0|#define RSTR_SET_EMBED_LEN(s, n) do {\
  |  |  |  |   48|      0|  size_t tmp_n = (n);\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:19): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   49|      0|  (s)->flags &= ~MRB_STR_EMBED_LEN_MASK;\
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|      0|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|      0|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      0|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   50|      0|  (s)->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|      0|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  |  |   51|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|  }\
  |  |   56|      1|  else {\
  |  |   57|      2|    (s)->as.heap.len = (mrb_ssize)(n);\
  |  |  ------------------
  |  |  |  Branch (57:36): [True: 0, False: 1]
  |  |  ------------------
  |  |   58|      1|  }\
  |  |   59|      1|} while (0)
  |  |  ------------------
  |  |  |  Branch (59:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1515|      1|  return str;
 1516|      1|}
mrb_bint_xor:
 1562|  3.26k|{
 1563|  3.26k|  struct RBigint *b3 = bint_new(mrb);
 1564|  3.26k|  struct RBigint *b1 = RBIGINT(x);
  ------------------
  |  |   59|  3.26k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  3.26k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1565|       |
 1566|  3.26k|#ifndef MRB_NO_FLOAT
 1567|  3.26k|  if (mrb_float_p(y)) {
  ------------------
  |  |  179|  3.26k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  3.26k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 912, False: 2.35k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1568|    912|    mpz_t z;
 1569|    912|    mpz_init_set_int(mrb, &z, (mrb_int)mrb_float(y));
  ------------------
  |  |  155|    912|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1570|    912|    mpz_xor(mrb, &b3->mp, &b1->mp, &z);
 1571|    912|    mpz_clear(mrb, &z);
 1572|    912|    return bint_norm(mrb, b3);
 1573|    912|  }
 1574|  2.35k|#endif
 1575|  2.35k|  y = mrb_as_bint(mrb, y);
 1576|  2.35k|  struct RBigint *b2 = RBIGINT(y);
  ------------------
  |  |   59|  2.35k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  2.35k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1577|  2.35k|  mpz_xor(mrb, &b3->mp, &b1->mp, &b2->mp);
 1578|  2.35k|  return bint_norm(mrb, b3);
 1579|  3.26k|}
mrb_bint_rshift:
 1608|  3.53k|{
 1609|  3.53k|  struct RBigint *b = RBIGINT(x);
  ------------------
  |  |   59|  3.53k|#define RBIGINT(v) ((struct RBigint*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|  3.53k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1610|  3.53k|  struct RBigint *b2 = bint_new(mrb);
 1611|  3.53k|  if (width < 0) {
  ------------------
  |  Branch (1611:7): [True: 2.76k, False: 769]
  ------------------
 1612|  2.76k|    mpz_mul_2exp(mrb, &b2->mp, &b->mp, -width);
 1613|  2.76k|  }
 1614|    769|  else {
 1615|    769|    mpz_div_2exp(mrb, &b2->mp, &b->mp, width);
 1616|    769|  }
 1617|  3.53k|  return bint_norm(mrb, b2);
 1618|  3.53k|}
bigint.c:bint_new:
 1011|  29.7k|{
 1012|  29.7k|  struct RBigint *b = MRB_OBJ_ALLOC(mrb, MRB_TT_BIGINT, mrb->integer_class);
  ------------------
  |  | 1200|  29.7k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 1013|  29.7k|  mpz_init(mrb, &b->mp);
 1014|  29.7k|  return b;
 1015|  29.7k|}
bigint.c:bint_new_int:
 1019|  18.3k|{
 1020|  18.3k|  struct RBigint *b = MRB_OBJ_ALLOC(mrb, MRB_TT_BIGINT, mrb->integer_class);
  ------------------
  |  | 1200|  18.3k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 1021|  18.3k|  mpz_init_set_int(mrb, &b->mp, x);
 1022|  18.3k|  return b;
 1023|  18.3k|}
bigint.c:mpz_init:
   29|   112k|{
   30|   112k|  s->p = NULL;
   31|   112k|  s->sn=0;
   32|   112k|  s->sz=0;
   33|   112k|}
bigint.c:zero:
  258|  2.99k|{
  259|  2.99k|  x->sn=0;
  260|  2.99k|  if (x->p) {
  ------------------
  |  Branch (260:7): [True: 0, False: 2.99k]
  ------------------
  261|      0|    x->sz=1;
  262|      0|    x->p[0]=0;
  263|      0|  }
  264|  2.99k|  else {
  265|  2.99k|    x->sz=0;
  266|  2.99k|  }
  267|  2.99k|}
bigint.c:mpz_clear:
  142|   112k|{
  143|   112k|  if (s->p) mrb_free(mrb, s->p);
  ------------------
  |  Branch (143:7): [True: 83.1k, False: 29.3k]
  ------------------
  144|   112k|  s->p = NULL;
  145|   112k|  s->sn = 0;
  146|   112k|  s->sz = 0;
  147|   112k|}
bigint.c:mpz_realloc:
   37|  83.5k|{
   38|  83.5k|  if (x->sz < size) {
  ------------------
  |  Branch (38:7): [True: 83.1k, False: 433]
  ------------------
   39|  83.1k|    x->p=(mp_limb*)mrb_realloc(mrb, x->p, size*sizeof(mp_limb));
   40|   221M|    for (size_t i=x->sz; i<size; i++)
  ------------------
  |  Branch (40:26): [True: 221M, False: 83.1k]
  ------------------
   41|   221M|      x->p[i] = 0;
   42|  83.1k|    x->sz = size;
   43|  83.1k|  }
   44|  83.5k|}
bigint.c:bint_norm:
 1078|  29.7k|{
 1079|  29.7k|  mrb_int i;
 1080|       |
 1081|  29.7k|  if (mpz_get_int(&b->mp, &i)) {
  ------------------
  |  Branch (1081:7): [True: 7.18k, False: 22.5k]
  ------------------
 1082|  7.18k|    return mrb_int_value(mrb, i);
 1083|  7.18k|  }
 1084|  22.5k|  return mrb_obj_value(b);
 1085|  29.7k|}
bigint.c:mpz_get_int:
  777|  30.9k|{
  778|  30.9k|  if (uzero(y)) {
  ------------------
  |  Branch (778:7): [True: 2.40k, False: 28.5k]
  ------------------
  779|  2.40k|    *v = 0;
  780|  2.40k|    return TRUE;
  ------------------
  |  |   54|  2.40k|#  define TRUE 1
  ------------------
  781|  2.40k|  }
  782|       |
  783|  28.5k|  mp_dbl_limb i = 0;
  784|  28.5k|  mp_limb *d = y->p + y->sz;
  785|       |
  786|  89.1k|  while (d-- > y->p) {
  ------------------
  |  Branch (786:10): [True: 75.2k, False: 13.9k]
  ------------------
  787|  75.2k|    if (HIGH(i) != 0) {
  ------------------
  |  |   19|  75.2k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|  75.2k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|  75.2k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (787:9): [True: 14.6k, False: 60.6k]
  ------------------
  788|       |      /* will overflow */
  789|  14.6k|      return FALSE;
  ------------------
  |  |   51|  14.6k|#  define FALSE 0
  ------------------
  790|  14.6k|    }
  791|  60.6k|    i = (i << DIG_SIZE) | *d;
  ------------------
  |  |   16|  60.6k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  60.6k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  792|  60.6k|  }
  793|  13.9k|  if (i > MRB_INT_MAX) {
  ------------------
  |  |   82|  13.9k|# define MRB_INT_MAX INT64_MAX
  ------------------
  |  Branch (793:7): [True: 9.14k, False: 4.77k]
  ------------------
  794|       |    /* overflow */
  795|  9.14k|    return FALSE;
  ------------------
  |  |   51|  9.14k|#  define FALSE 0
  ------------------
  796|  9.14k|  }
  797|  4.77k|  if (y->sn < 0) {
  ------------------
  |  Branch (797:7): [True: 2.81k, False: 1.96k]
  ------------------
  798|  2.81k|    *v = -(mrb_int)i;
  799|  2.81k|  }
  800|  1.96k|  else {
  801|  1.96k|    *v = (mrb_int)i;
  802|  1.96k|  }
  803|  4.77k|  return TRUE;
  ------------------
  |  |   54|  4.77k|#  define TRUE 1
  ------------------
  804|  13.9k|}
bigint.c:digits:
  163|  12.1k|{
  164|  12.1k|  size_t i;
  165|       |
  166|  12.1k|  if (x->sz == 0) return 0;
  ------------------
  |  Branch (166:7): [True: 0, False: 12.1k]
  ------------------
  167|  16.5k|  for (i = x->sz - 1; x->p[i] == 0; i--)
  ------------------
  |  Branch (167:23): [True: 4.44k, False: 12.0k]
  ------------------
  168|  4.44k|    if (i == 0) break;
  ------------------
  |  Branch (168:9): [True: 63, False: 4.38k]
  ------------------
  169|  12.1k|  return i+1;
  170|  12.1k|}
bigint.c:mpz_add:
  272|  14.7k|{
  273|  14.7k|  int mg;
  274|  14.7k|  mpz_t z;
  275|       |
  276|  14.7k|  if (x->sn == 0) {
  ------------------
  |  Branch (276:7): [True: 1.10k, False: 13.6k]
  ------------------
  277|  1.10k|    mpz_set(mrb, zz, y);
  278|  1.10k|    return;
  279|  1.10k|  }
  280|  13.6k|  if (y->sn == 0) {
  ------------------
  |  Branch (280:7): [True: 412, False: 13.2k]
  ------------------
  281|    412|    mpz_set(mrb, zz, x);
  282|    412|    return;
  283|    412|  }
  284|  13.2k|  mpz_init(mrb, &z);
  285|       |
  286|  13.2k|  if (x->sn > 0 && y->sn > 0) {
  ------------------
  |  Branch (286:7): [True: 6.73k, False: 6.48k]
  |  Branch (286:20): [True: 3.36k, False: 3.37k]
  ------------------
  287|  3.36k|    uadd(mrb, &z, x, y);
  288|  3.36k|    z.sn = 1;
  289|  3.36k|  }
  290|  9.85k|  else if (x->sn < 0 && y->sn < 0) {
  ------------------
  |  Branch (290:12): [True: 6.48k, False: 3.37k]
  |  Branch (290:25): [True: 3.64k, False: 2.83k]
  ------------------
  291|  3.64k|    uadd(mrb, &z, x, y);
  292|  3.64k|    z.sn = -1;
  293|  3.64k|  }
  294|  6.20k|  else {
  295|       |    /* signs differ */
  296|  6.20k|    if ((mg = ucmp(x,y)) == 0) {
  ------------------
  |  Branch (296:9): [True: 387, False: 5.82k]
  ------------------
  297|    387|      zero(&z);
  298|    387|    }
  299|  5.82k|    else if (mg > 0) {  /* abs(y) < abs(x) */
  ------------------
  |  Branch (299:14): [True: 3.99k, False: 1.82k]
  ------------------
  300|  3.99k|      usub(mrb, &z, x, y);
  301|  3.99k|      z.sn = (x->sn > 0 && y->sn < 0) ? 1 : (-1);
  ------------------
  |  Branch (301:15): [True: 1.58k, False: 2.41k]
  |  Branch (301:28): [True: 1.58k, False: 0]
  ------------------
  302|  3.99k|    }
  303|  1.82k|    else { /* abs(y) > abs(x) */
  304|  1.82k|      usub(mrb, &z, y, x);
  305|  1.82k|      z.sn = (x->sn < 0 && y->sn > 0) ? 1 : (-1);
  ------------------
  |  Branch (305:15): [True: 307, False: 1.51k]
  |  Branch (305:28): [True: 307, False: 0]
  ------------------
  306|  1.82k|    }
  307|  6.20k|  }
  308|  13.2k|  trim(&z);
  309|  13.2k|  mpz_move(mrb, zz, &z);
  310|  13.2k|}
bigint.c:mpz_set:
   48|  11.6k|{
   49|  11.6k|  size_t i, k = x->sz;
   50|       |
   51|  11.6k|  mpz_realloc(mrb, y, k);
   52|  44.3M|  for (i=0;i < k; i++)
  ------------------
  |  Branch (52:12): [True: 44.2M, False: 11.6k]
  ------------------
   53|  44.2M|    y->p[i] = x->p[i];
   54|       |
   55|  11.9k|  for (;i<y->sz;i++)
  ------------------
  |  Branch (55:9): [True: 306, False: 11.6k]
  ------------------
   56|    306|    y->p[i] = 0;
   57|       |
   58|  11.6k|  y->sn = x->sn;
   59|  11.6k|}
bigint.c:uadd:
  183|  7.00k|{
  184|  7.00k|  if (y->sz < x->sz) {
  ------------------
  |  Branch (184:7): [True: 3.09k, False: 3.90k]
  ------------------
  185|  3.09k|    mpz_t *t;                   /* swap x,y */
  186|  3.09k|    t=x; x=y; y=t;
  187|  3.09k|  }
  188|       |
  189|       |  /* now y->sz >= x->sz */
  190|  7.00k|  mpz_realloc(mrb, z, y->sz+1);
  191|       |
  192|  7.00k|  mp_dbl_limb c = 0;
  193|  7.00k|  size_t i;
  194|  19.2k|  for (i=0; i<x->sz; i++) {
  ------------------
  |  Branch (194:13): [True: 12.2k, False: 7.00k]
  ------------------
  195|  12.2k|    c += (mp_dbl_limb)y->p[i] + (mp_dbl_limb)x->p[i];
  196|  12.2k|    z->p[i] = LOW(c);
  ------------------
  |  |   20|  12.2k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|  12.2k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|  12.2k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|  12.2k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|  12.2k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  197|  12.2k|    c >>= DIG_SIZE;
  ------------------
  |  |   16|  12.2k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  12.2k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  198|  12.2k|  }
  199|  30.5k|  for (;i<y->sz; i++) {
  ------------------
  |  Branch (199:9): [True: 23.5k, False: 7.00k]
  ------------------
  200|  23.5k|    c += y->p[i];
  201|  23.5k|    z->p[i] = LOW(c);
  ------------------
  |  |   20|  23.5k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|  23.5k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|  23.5k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|  23.5k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|  23.5k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  202|  23.5k|    c >>= DIG_SIZE;
  ------------------
  |  |   16|  23.5k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  23.5k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  203|  23.5k|  }
  204|  7.00k|  z->p[y->sz] = (mp_limb)c;
  205|  7.00k|  trim(z);
  206|  7.00k|}
bigint.c:ucmp:
  233|  13.5k|{
  234|  13.5k|  if (y->sz < x->sz) return -1;
  ------------------
  |  Branch (234:7): [True: 3.25k, False: 10.2k]
  ------------------
  235|  10.2k|  if (y->sz > x->sz) return 1;
  ------------------
  |  Branch (235:7): [True: 5.38k, False: 4.89k]
  ------------------
  236|  4.89k|  if (x->sz == 0) return 0;
  ------------------
  |  Branch (236:7): [True: 0, False: 4.89k]
  ------------------
  237|  16.2k|  for (size_t i=x->sz-1;; i--) {
  238|  16.2k|    mp_limb a = y->p[i];
  239|  16.2k|    mp_limb b = x->p[i];
  240|  16.2k|    if (a > b) return 1;
  ------------------
  |  Branch (240:9): [True: 1.97k, False: 14.2k]
  ------------------
  241|  14.2k|    if (a < b) return -1;
  ------------------
  |  Branch (241:9): [True: 909, False: 13.3k]
  ------------------
  242|  13.3k|    if (i == 0) break;
  ------------------
  |  Branch (242:9): [True: 2.01k, False: 11.3k]
  ------------------
  243|  13.3k|  }
  244|  2.01k|  return 0;
  245|  4.89k|}
bigint.c:usub:
  212|  5.82k|{
  213|  5.82k|  mpz_realloc(mrb, z, (size_t)(y->sz));
  214|  5.82k|  mp_dbl_limb_signed b = 0;
  215|  5.82k|  size_t i;
  216|  14.6k|  for (i=0;i<x->sz;i++) {
  ------------------
  |  Branch (216:12): [True: 8.80k, False: 5.82k]
  ------------------
  217|  8.80k|    b += (mp_dbl_limb_signed)y->p[i];
  218|  8.80k|    b -= (mp_dbl_limb_signed)x->p[i];
  219|  8.80k|    z->p[i] = LOW(b);
  ------------------
  |  |   20|  8.80k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|  8.80k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|  8.80k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|  8.80k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|  8.80k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  220|  8.80k|    b = HIGH(b);
  ------------------
  |  |   19|  8.80k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|  8.80k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|  8.80k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  221|  8.80k|  }
  222|  88.1M|  for (;i<y->sz; i++) {
  ------------------
  |  Branch (222:9): [True: 88.1M, False: 5.82k]
  ------------------
  223|  88.1M|    b += y->p[i];
  224|  88.1M|    z->p[i] = LOW(b);
  ------------------
  |  |   20|  88.1M|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|  88.1M|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|  88.1M|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|  88.1M|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|  88.1M|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  88.1M|    b = HIGH(b);
  ------------------
  |  |   19|  88.1M|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|  88.1M|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|  88.1M|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|  88.1M|  }
  227|  5.82k|  z->sz = digits(z);
  228|  5.82k|}
bigint.c:trim:
  174|  37.8k|{
  175|  67.7k|  while (x->sz && x->p[x->sz-1] == 0) {
  ------------------
  |  Branch (175:10): [True: 67.2k, False: 507]
  |  Branch (175:19): [True: 29.9k, False: 37.3k]
  ------------------
  176|  29.9k|    x->sz--;
  177|  29.9k|  }
  178|  37.8k|}
bigint.c:mpz_move:
  151|  31.1k|{
  152|  31.1k|  mpz_clear(mrb, y);
  153|  31.1k|  y->sn = x->sn;
  154|  31.1k|  y->sz = x->sz;
  155|  31.1k|  y->p = x->p;
  156|  31.1k|  x->p = NULL;
  157|  31.1k|  x->sn = 0;
  158|  31.1k|  x->sz = 0;
  159|  31.1k|}
bigint.c:mpz_sub:
  315|  7.23k|{
  316|  7.23k|  mpz_t u;
  317|       |
  318|  7.23k|  mpz_init(mrb, &u);
  319|  7.23k|  mpz_set(mrb, &u, y);
  320|  7.23k|  u.sn = -(u.sn);
  321|  7.23k|  mpz_add(mrb, z, x, &u);
  322|  7.23k|  mpz_clear(mrb, &u);
  323|  7.23k|}
bigint.c:mpz_mul:
  339|  4.32k|{
  340|  4.32k|  size_t i, j;
  341|  4.32k|  mpz_t w;
  342|       |
  343|  4.32k|  if (uzero(u) || uzero(v)) {
  ------------------
  |  Branch (343:7): [True: 0, False: 4.32k]
  |  Branch (343:19): [True: 122, False: 4.20k]
  ------------------
  344|    122|    mpz_set_int(mrb, ww, 0);
  345|    122|    return;
  346|    122|  }
  347|  4.20k|  mpz_init(mrb, &w);
  348|  4.20k|  mpz_realloc(mrb, &w, u->sz + v->sz);
  349|  53.2k|  for (j=0; j < u->sz; j++) {
  ------------------
  |  Branch (349:13): [True: 49.0k, False: 4.20k]
  ------------------
  350|  49.0k|    mp_dbl_limb cc = (mp_limb)0;
  351|  49.0k|    mp_limb u0 = u->p[j];
  352|  49.0k|    if (u0 == 0) continue;
  ------------------
  |  Branch (352:9): [True: 38.1k, False: 10.8k]
  ------------------
  353|  53.5k|    for (i=0; i < v->sz; i++) {
  ------------------
  |  Branch (353:15): [True: 42.6k, False: 10.8k]
  ------------------
  354|  42.6k|      mp_limb v0 = v->p[i];
  355|  42.6k|      if (v0 == 0) continue;
  ------------------
  |  Branch (355:11): [True: 16.1k, False: 26.5k]
  ------------------
  356|  26.5k|      cc += (mp_dbl_limb)w.p[i+j] + (mp_dbl_limb)u0 * (mp_dbl_limb)v0;
  357|  26.5k|      w.p[i+j] = LOW(cc);
  ------------------
  |  |   20|  26.5k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|  26.5k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|  26.5k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|  26.5k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|  26.5k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  358|  26.5k|      cc = HIGH(cc);
  ------------------
  |  |   19|  26.5k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|  26.5k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|  26.5k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  359|  26.5k|    }
  360|  10.8k|    if (cc) {
  ------------------
  |  Branch (360:9): [True: 7.23k, False: 3.61k]
  ------------------
  361|  7.23k|      w.p[i+j] = (mp_limb)cc;
  362|  7.23k|    }
  363|  10.8k|  }
  364|  4.20k|  w.sn = u->sn * v->sn;
  365|  4.20k|  trim(&w);
  366|  4.20k|  mpz_move(mrb, ww, &w);
  367|  4.20k|}
bigint.c:mpz_set_int:
   70|  31.5k|{
   71|  31.5k|  mrb_uint u;
   72|       |
   73|  31.5k|  if (v == 0) {
  ------------------
  |  Branch (73:7): [True: 3.39k, False: 28.1k]
  ------------------
   74|  3.39k|    y->sn=0;
   75|  3.39k|    u = 0;
   76|  3.39k|  }
   77|  28.1k|  else if (v > 0) {
  ------------------
  |  Branch (77:12): [True: 17.3k, False: 10.8k]
  ------------------
   78|  17.3k|    y->sn = 1;
   79|  17.3k|    u = v;
   80|  17.3k|  }
   81|  10.8k|  else /* if (v < 0) */ {
   82|  10.8k|    y->sn = -1;
   83|  10.8k|    if (v == MRB_INT_MIN) u = v;
  ------------------
  |  |   81|  10.8k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (83:9): [True: 5.21k, False: 5.59k]
  ------------------
   84|  5.59k|    else u = -v;
   85|  10.8k|  }
   86|  31.5k|#if MRB_INT_BIT > DIG_SIZE
   87|  31.5k|  if ((u & ~DIG_MASK) != 0) {
  ------------------
  |  |   18|  31.5k|#define DIG_MASK (DIG_BASE - 1)
  |  |  ------------------
  |  |  |  |   17|  31.5k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   16|  31.5k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|  31.5k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (87:7): [True: 10.0k, False: 21.5k]
  ------------------
   88|  10.0k|    mpz_realloc(mrb, y, 2);
   89|  10.0k|    y->p[1] = (mp_limb)HIGH(u);
  ------------------
  |  |   19|  10.0k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|  10.0k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|  10.0k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   90|  10.0k|    y->p[0] = (mp_limb)LOW(u);
  ------------------
  |  |   20|  10.0k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|  10.0k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|  10.0k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|  10.0k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|  10.0k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   91|  10.0k|  }
   92|  21.5k|  else
   93|  21.5k|#endif
   94|  21.5k|  {
   95|  21.5k|    mpz_realloc(mrb, y, 1);
   96|  21.5k|    y->p[0] = (mp_limb)u;
   97|  21.5k|  }
   98|  31.5k|}
bigint.c:uzero:
  249|  74.0k|{
  250|  88.7M|  for (size_t i=0; i < x->sz; i++)
  ------------------
  |  Branch (250:20): [True: 88.7M, False: 8.03k]
  ------------------
  251|  88.7M|    if (x->p[i] != 0)
  ------------------
  |  Branch (251:9): [True: 66.0k, False: 88.6M]
  ------------------
  252|  66.0k|      return 0;
  253|  8.03k|  return 1;
  254|  74.0k|}
bigint.c:mpz_mdiv:
  536|  3.62k|{
  537|  3.62k|  mpz_t r;
  538|  3.62k|  short sn1 = x->sn, sn2 = y->sn, qsign;
  539|       |
  540|  3.62k|  if (uzero(x)) {
  ------------------
  |  Branch (540:7): [True: 320, False: 3.30k]
  ------------------
  541|    320|    mpz_init_set_int(mrb, q, 0);
  542|    320|    return;
  543|    320|  }
  544|  3.30k|  mpz_init(mrb, &r);
  545|  3.30k|  udiv(mrb, q, &r, x, y);
  546|  3.30k|  qsign = q->sn = sn1*sn2;
  547|  3.30k|  if (uzero(q))
  ------------------
  |  Branch (547:7): [True: 1.40k, False: 1.90k]
  ------------------
  548|  1.40k|    q->sn = 0;
  549|       |  /* now if r != 0 and q < 0 we need to round q towards -inf */
  550|  3.30k|  if (!uzero(&r) && qsign < 0)
  ------------------
  |  Branch (550:7): [True: 1.73k, False: 1.57k]
  |  Branch (550:21): [True: 734, False: 999]
  ------------------
  551|    734|    mpz_sub_int(mrb, q, q, 1);
  552|  3.30k|  mpz_clear(mrb, &r);
  553|  3.30k|}
bigint.c:udiv:
  466|  5.75k|{
  467|       |  /* simple cases */
  468|  5.75k|  int cmp = ucmp(xx, yy);
  469|  5.75k|  if (cmp == 0) {
  ------------------
  |  Branch (469:7): [True: 667, False: 5.08k]
  ------------------
  470|    667|    mpz_set_int(mrb, qq, 1);
  471|    667|    zero(rr);
  472|    667|    return;
  473|    667|  }
  474|  5.08k|  else if (cmp < 0) {
  ------------------
  |  Branch (474:12): [True: 1.94k, False: 3.14k]
  ------------------
  475|  1.94k|    zero(qq);
  476|  1.94k|    mpz_set(mrb, rr, xx);
  477|  1.94k|    return;
  478|  1.94k|  }
  479|       |
  480|  3.14k|  mpz_t q, x, y;
  481|  3.14k|  size_t i;
  482|       |
  483|  3.14k|  mrb_assert(!uzero(yy));       /* divided by zero */
  ------------------
  |  |   68|  3.14k|#define mrb_assert(p) ((void)0)
  ------------------
  484|  3.14k|  mpz_init(mrb, &q);
  485|  3.14k|  mpz_init(mrb, &x);
  486|  3.14k|  mpz_init(mrb, &y);
  487|  3.14k|  mpz_realloc(mrb, &x, xx->sz+1);
  488|  3.14k|  size_t yd = digits(yy);
  489|  3.14k|  size_t ns = lzb(yy->p[yd-1]);
  490|  3.14k|  ulshift(mrb, &x, xx, ns);
  491|  3.14k|  ulshift(mrb, &y, yy, ns);
  492|  3.14k|  size_t xd = digits(&x);
  493|  3.14k|  mpz_realloc(mrb, &q, xd);
  494|  3.14k|  mp_dbl_limb z = y.p[yd-1];
  495|  3.14k|  if (xd>=yd) {
  ------------------
  |  Branch (495:7): [True: 3.12k, False: 28]
  ------------------
  496|   239k|    for (size_t j=xd-yd;; j--) {
  497|   239k|      mp_dbl_limb_signed b=0;
  498|   239k|      mp_dbl_limb qhat;
  499|       |
  500|   239k|      if (j+yd == xd)
  ------------------
  |  Branch (500:11): [True: 3.12k, False: 235k]
  ------------------
  501|  3.12k|        qhat = x.p[j+yd-1] / z;
  502|   235k|      else
  503|   235k|        qhat = (((mp_dbl_limb)x.p[j+yd] << DIG_SIZE) + x.p[j+yd-1]) / z;
  ------------------
  |  |   16|   235k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|   235k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  504|   239k|      if (qhat) {
  ------------------
  |  Branch (504:11): [True: 26.0k, False: 212k]
  ------------------
  505|   144k|        for (i=0; i<yd; i++) {
  ------------------
  |  Branch (505:19): [True: 118k, False: 26.0k]
  ------------------
  506|   118k|          mp_dbl_limb zz = qhat * y.p[i];
  507|   118k|          mp_dbl_limb_signed u = LOW(b)+x.p[i+j]-LOW(zz);
  ------------------
  |  |   20|   118k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|   118k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|   118k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|   118k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|   118k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                        mp_dbl_limb_signed u = LOW(b)+x.p[i+j]-LOW(zz);
  ------------------
  |  |   20|   118k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|   118k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|   118k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|   118k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|   118k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  508|   118k|          x.p[i+j] = LOW(u);
  ------------------
  |  |   20|   118k|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|   118k|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|   118k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|   118k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|   118k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  509|   118k|          b = HIGH(b) - HIGH(zz) + HIGH(u);
  ------------------
  |  |   19|   118k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|   118k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|   118k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                        b = HIGH(b) - HIGH(zz) + HIGH(u);
  ------------------
  |  |   19|   118k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|   118k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|   118k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                        b = HIGH(b) - HIGH(zz) + HIGH(u);
  ------------------
  |  |   19|   118k|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|   118k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|   118k|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  510|   118k|        }
  511|  26.0k|        b += x.p[i+j];
  512|  26.0k|      }
  513|   239k|      for (; b!=0; qhat--) {
  ------------------
  |  Branch (513:14): [True: 252, False: 239k]
  ------------------
  514|    252|        mp_dbl_limb c = 0;
  515|    976|        for (i=0; i<yd; i++) {
  ------------------
  |  Branch (515:19): [True: 724, False: 252]
  ------------------
  516|    724|          c += (mp_dbl_limb)x.p[i+j] + (mp_dbl_limb)y.p[i];
  517|    724|          x.p[i+j] = LOW(c);
  ------------------
  |  |   20|    724|#define LOW(x)  ((x) & DIG_MASK)
  |  |  ------------------
  |  |  |  |   18|    724|#define DIG_MASK (DIG_BASE - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   17|    724|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   16|    724|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|    724|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  518|    724|          c = HIGH(c);
  ------------------
  |  |   19|    724|#define HIGH(x) ((x) >> DIG_SIZE)
  |  |  ------------------
  |  |  |  |   16|    724|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   46|    724|#define MPZ_DIG_SIZE 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  519|    724|        }
  520|    252|        b += c;
  521|    252|      }
  522|   239k|      q.p[j] = (mp_limb)qhat;
  523|   239k|      if (j == 0) break;
  ------------------
  |  Branch (523:11): [True: 3.12k, False: 235k]
  ------------------
  524|   239k|    }
  525|  3.12k|  }
  526|  3.14k|  x.sz = yy->sz;
  527|  3.14k|  urshift(mrb, rr, &x, ns);
  528|  3.14k|  trim(&q);
  529|  3.14k|  mpz_move(mrb, qq, &q);
  530|  3.14k|  mpz_clear(mrb, &x);
  531|  3.14k|  mpz_clear(mrb, &y);
  532|  3.14k|}
bigint.c:lzb:
  387|  3.14k|{
  388|  3.14k|  if (x == 0) return 0;
  ------------------
  |  Branch (388:7): [True: 0, False: 3.14k]
  ------------------
  389|  3.14k|#if (defined(__GNUC__) || __has_builtin(__builtin_clz))
  390|  3.14k|  if (sizeof(mp_limb) == sizeof(int64_t))
  ------------------
  |  Branch (390:7): [Folded - Ignored]
  ------------------
  391|      0|    return __builtin_clzll(x);
  392|  3.14k|  else if (sizeof(mp_limb) == sizeof(int32_t))
  ------------------
  |  Branch (392:12): [Folded - Ignored]
  ------------------
  393|  3.14k|    return __builtin_clz(x);
  394|      0|#endif
  395|       |
  396|      0|  int j=0;
  397|       |
  398|      0|  for (mp_limb i = ((mp_limb)1 << (DIG_SIZE-1)); i && !(x&i); j++,i>>=1)
  ------------------
  |  |   16|      0|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|      0|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  |  Branch (398:50): [True: 0, False: 0]
  |  Branch (398:55): [True: 0, False: 0]
  ------------------
  399|      0|    ;
  400|      0|  return j;
  401|  3.14k|}
bigint.c:ulshift:
  436|  8.74k|{
  437|  8.74k|  mrb_assert(n < DIG_SIZE);
  ------------------
  |  |   68|  8.74k|#define mrb_assert(p) ((void)0)
  ------------------
  438|  8.74k|  if (n == 0)
  ------------------
  |  Branch (438:7): [True: 612, False: 8.13k]
  ------------------
  439|    612|    mpz_set(mrb, c1, a);
  440|  8.13k|  else if (uzero(a)) {
  ------------------
  |  Branch (440:12): [True: 0, False: 8.13k]
  ------------------
  441|      0|    mpz_set_int(mrb, c1, 0);
  442|      0|  }
  443|  8.13k|  else {
  444|  8.13k|    mp_limb cc = 0;
  445|  8.13k|    mpz_t c;
  446|  8.13k|    mp_limb rm = (((mp_dbl_limb)1<<n) - 1) << (DIG_SIZE-n);
  ------------------
  |  |   16|  8.13k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  8.13k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  447|       |
  448|  8.13k|    mpz_init(mrb, &c);
  449|  8.13k|    mpz_realloc(mrb, &c, a->sz+1);
  450|       |
  451|  8.13k|    size_t i;
  452|  44.1M|    for (i=0; i<a->sz; i++) {
  ------------------
  |  Branch (452:15): [True: 44.1M, False: 8.13k]
  ------------------
  453|  44.1M|      c.p[i] = ((a->p[i] << n) | cc) & DIG_MASK;
  ------------------
  |  |   18|  44.1M|#define DIG_MASK (DIG_BASE - 1)
  |  |  ------------------
  |  |  |  |   17|  44.1M|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   16|  44.1M|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|  44.1M|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  454|  44.1M|      cc = (a->p[i] & rm) >> (DIG_SIZE-n);
  ------------------
  |  |   16|  44.1M|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  44.1M|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  455|  44.1M|    }
  456|  8.13k|    c.p[i] = cc;
  457|  8.13k|    trim(&c);
  458|  8.13k|    mpz_move(mrb, c1, &c);
  459|  8.13k|  }
  460|  8.74k|}
bigint.c:urshift:
  407|  3.83k|{
  408|  3.83k|  mrb_assert(n < DIG_SIZE);
  ------------------
  |  |   68|  3.83k|#define mrb_assert(p) ((void)0)
  ------------------
  409|       |
  410|  3.83k|  if (n == 0)
  ------------------
  |  Branch (410:7): [True: 306, False: 3.53k]
  ------------------
  411|    306|    mpz_set(mrb, c1, a);
  412|  3.53k|  else if (uzero(a)) {
  ------------------
  |  Branch (412:12): [True: 1.42k, False: 2.10k]
  ------------------
  413|  1.42k|    mpz_set_int(mrb, c1, 0);
  414|  1.42k|  }
  415|  2.10k|  else {
  416|  2.10k|    mpz_t c;
  417|  2.10k|    mp_limb cc = 0;
  418|  2.10k|    mp_dbl_limb rm = (((mp_dbl_limb)1<<n) - 1);
  419|       |
  420|  2.10k|    mpz_init(mrb, &c);
  421|  2.10k|    mpz_realloc(mrb, &c, a->sz);
  422|  9.11k|    for (size_t i=a->sz-1;; i--) {
  423|  9.11k|      c.p[i] = ((a->p[i] >> n) | cc) & DIG_MASK;
  ------------------
  |  |   18|  9.11k|#define DIG_MASK (DIG_BASE - 1)
  |  |  ------------------
  |  |  |  |   17|  9.11k|#define DIG_BASE (1ULL << DIG_SIZE)
  |  |  |  |  ------------------
  |  |  |  |  |  |   16|  9.11k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|  9.11k|#define MPZ_DIG_SIZE 32
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  424|  9.11k|      cc = (a->p[i] & rm) << (DIG_SIZE - n);
  ------------------
  |  |   16|  9.11k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  9.11k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  425|  9.11k|      if (i == 0) break;
  ------------------
  |  Branch (425:11): [True: 2.10k, False: 7.01k]
  ------------------
  426|  9.11k|    }
  427|  2.10k|    trim(&c);
  428|  2.10k|    mpz_move(mrb, c1, &c);
  429|  2.10k|  }
  430|  3.83k|}
bigint.c:mpz_init_set_int:
  135|  29.3k|{
  136|  29.3k|  mpz_init(mrb, y);
  137|  29.3k|  mpz_set_int(mrb, y, v);
  138|  29.3k|}
bigint.c:mpz_mmod:
  557|  2.45k|{
  558|  2.45k|  mpz_t q;
  559|  2.45k|  short sn1 = x->sn, sn2 = y->sn, sn3;
  560|       |
  561|  2.45k|  mpz_init(mrb, &q);
  562|  2.45k|  if (sn1 == 0) {
  ------------------
  |  Branch (562:7): [True: 0, False: 2.45k]
  ------------------
  563|      0|    zero(r);
  564|      0|    return;
  565|      0|  }
  566|  2.45k|  udiv(mrb, &q, r, x, y);
  567|  2.45k|  mpz_clear(mrb, &q);
  568|  2.45k|  if (uzero(r)) {
  ------------------
  |  Branch (568:7): [True: 521, False: 1.93k]
  ------------------
  569|    521|    r->sn = 0;
  570|    521|    return;
  571|    521|  }
  572|  1.93k|  sn3 = sn1*sn2;
  573|  1.93k|  if (sn3 > 0)
  ------------------
  |  Branch (573:7): [True: 495, False: 1.43k]
  ------------------
  574|    495|    r->sn = sn1;
  575|  1.43k|  else if (sn1 < 0 && sn2 > 0) {
  ------------------
  |  Branch (575:12): [True: 259, False: 1.17k]
  |  Branch (575:23): [True: 259, False: 0]
  ------------------
  576|    259|    r->sn = 1;
  577|    259|    mpz_sub(mrb, r, y, r);
  578|    259|  }
  579|  1.17k|  else {
  580|  1.17k|    r->sn = 1;
  581|  1.17k|    mpz_add(mrb, r, y, r);
  582|  1.17k|  }
  583|  1.93k|}
bigint.c:mpz_cmp:
  638|  1.92k|{
  639|  1.92k|  int abscmp;
  640|  1.92k|  if (x->sn < 0 && y->sn > 0)
  ------------------
  |  Branch (640:7): [True: 466, False: 1.46k]
  |  Branch (640:20): [True: 42, False: 424]
  ------------------
  641|     42|    return (-1);
  642|  1.88k|  if (x->sn > 0 && y->sn < 0)
  ------------------
  |  Branch (642:7): [True: 1.46k, False: 424]
  |  Branch (642:20): [True: 314, False: 1.14k]
  ------------------
  643|    314|    return 1;
  644|  1.57k|  abscmp=ucmp(x, y);
  645|  1.57k|  if (x->sn >=0 && y->sn >=0)
  ------------------
  |  Branch (645:7): [True: 1.14k, False: 424]
  |  Branch (645:20): [True: 1.14k, False: 0]
  ------------------
  646|  1.14k|    return abscmp;
  647|    424|  return (-abscmp);          // if (x->sn <=0 && y->sn <=0)
  648|  1.57k|}
bigint.c:mpz_sizeinbase:
  653|      1|{
  654|      1|  size_t i, j;
  655|       |
  656|      1|  size_t bits = digits(x) * DIG_SIZE;
  ------------------
  |  |   16|      1|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|      1|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  657|      1|  mrb_assert(2 <= base && base <= 36);
  ------------------
  |  |   68|      1|#define mrb_assert(p) ((void)0)
  ------------------
  658|       |
  659|      1|  if (x->sz == 0) return 0;
  ------------------
  |  Branch (659:7): [True: 0, False: 1]
  ------------------
  660|      5|  for (j=0,i=1; i<=(size_t)base; i*=2,j++)
  ------------------
  |  Branch (660:17): [True: 4, False: 1]
  ------------------
  661|      4|    ;
  662|      1|  return bits/(j-1)+1;
  663|      1|}
bigint.c:mpz_get_str:
  711|      1|{
  712|      1|  mrb_assert(2 <= base && base <= 36);
  ------------------
  |  |   68|      1|#define mrb_assert(p) ((void)0)
  ------------------
  713|      1|  if (uzero(x)) {
  ------------------
  |  Branch (713:7): [True: 0, False: 1]
  ------------------
  714|      0|    *s='0';
  715|      0|    *(s+1)='\0';
  716|      0|    return s;
  717|      0|  }
  718|       |
  719|      1|  char *ps = s;
  720|      1|  char *se = s+sz;
  721|      1|  int xlen = (int)digits(x);
  722|      1|  mp_limb *t = (mp_limb*)mrb_malloc(mrb, xlen*sizeof(mp_limb));
  723|      1|  mp_limb *tend = t + xlen;
  724|      1|  memcpy(t, x->p, xlen*sizeof(mp_limb));
  725|      1|  mp_limb b2 = (mp_limb)base;
  726|      1|  const int blim = (sizeof(mp_limb)<4)?(base<=10?4:3):(base<=10?9:5);
  ------------------
  |  Branch (726:20): [Folded - Ignored]
  |  Branch (726:41): [True: 0, False: 0]
  |  Branch (726:56): [True: 1, False: 0]
  ------------------
  727|      9|  for (int i=1; i<blim; i++) {
  ------------------
  |  Branch (727:17): [True: 8, False: 1]
  ------------------
  728|      8|    b2 *= (mp_limb)base;
  729|      8|  }
  730|       |
  731|      3|  for (;;) {
  732|      3|    mp_limb *d = tend;
  733|      3|    mp_dbl_limb a = 0;
  734|     12|    while (--d >= t) {
  ------------------
  |  Branch (734:12): [True: 9, False: 3]
  ------------------
  735|      9|      mp_limb d0 = *d;
  736|      9|      a = (a<<DIG_SIZE) | d0;
  ------------------
  |  |   16|      9|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|      9|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  737|      9|      *d = (mp_limb)(a / b2);
  738|      9|      a %= b2;
  739|      9|    }
  740|       |
  741|       |    // convert to character
  742|     30|    for (int i=0; i<blim; i++) {
  ------------------
  |  Branch (742:19): [True: 27, False: 3]
  ------------------
  743|     27|      mp_limb a0 = (mp_limb)(a % base);
  744|     27|      if (a0 < 10) a0 += '0';
  ------------------
  |  Branch (744:11): [True: 27, False: 0]
  ------------------
  745|      0|      else a0 += 'a' - 10;
  746|     27|      if (s == se) break;
  ------------------
  |  Branch (746:11): [True: 0, False: 27]
  ------------------
  747|     27|      *s++ = (char)a0;
  748|     27|      a /= base;
  749|     27|    }
  750|       |
  751|       |    // check if number is zero
  752|      6|    for (d = t; d < tend; d++) {
  ------------------
  |  Branch (752:17): [True: 5, False: 1]
  ------------------
  753|      5|      if (*d != 0) break;
  ------------------
  |  Branch (753:11): [True: 2, False: 3]
  ------------------
  754|      5|    }
  755|      3|    if (d == tend) goto done;
  ------------------
  |  Branch (755:9): [True: 1, False: 2]
  ------------------
  756|      3|  }
  757|       |
  758|      1| done:
  759|      8|  while (ps<s && s[-1]=='0') s--;
  ------------------
  |  Branch (759:10): [True: 8, False: 0]
  |  Branch (759:18): [True: 7, False: 1]
  ------------------
  760|      1|  mrb_free(mrb, t);
  761|      1|  if (x->sn < 0) {
  ------------------
  |  Branch (761:7): [True: 0, False: 1]
  ------------------
  762|      0|    *s++ = '-';
  763|      0|  }
  764|       |
  765|       |  /* reverse string */
  766|     11|  for (char *u = ps,*v=s-1; u < v; u++,v--) {
  ------------------
  |  Branch (766:29): [True: 10, False: 1]
  ------------------
  767|     10|    char temp = *u;
  768|     10|    *u = *v;
  769|     10|    *v = temp;
  770|     10|  }
  771|      1|  *s = '\0'; /* null termination */
  772|      1|  return ps;
  773|      1|}
bigint.c:mpz_xor:
  905|  3.26k|{
  906|  3.26k|  size_t i;
  907|       |
  908|  3.26k|  size_t sz = imax(x->sz, y->sz);
  ------------------
  |  |   23|  3.26k|#define imax(x,y) (((x)>(y))?(x):(y))
  |  |  ------------------
  |  |  |  Branch (23:20): [True: 1.57k, False: 1.69k]
  |  |  ------------------
  ------------------
  909|  3.26k|  mpz_realloc(mrb, z, sz);
  910|  96.8k|  for (i=0; i < sz; i++)
  ------------------
  |  Branch (910:13): [True: 93.6k, False: 3.26k]
  ------------------
  911|  93.6k|    z->p[i] = dg(x,i) ^ dg(y,i);
  ------------------
  |  |   25|  93.6k|#define dg(x,i) (((size_t)i < (x)->sz)?(x)->p[i]:0)
  |  |  ------------------
  |  |  |  Branch (25:18): [True: 13.3k, False: 80.2k]
  |  |  ------------------
  ------------------
                  z->p[i] = dg(x,i) ^ dg(y,i);
  ------------------
  |  |   25|  93.6k|#define dg(x,i) (((size_t)i < (x)->sz)?(x)->p[i]:0)
  |  |  ------------------
  |  |  |  Branch (25:18): [True: 85.8k, False: 7.78k]
  |  |  ------------------
  ------------------
  912|  3.26k|  if ((x->sn <= 0 && y->sn > 0) || (x->sn > 0 && y->sn <=0))
  ------------------
  |  Branch (912:8): [True: 544, False: 2.72k]
  |  Branch (912:22): [True: 189, False: 355]
  |  Branch (912:37): [True: 2.72k, False: 355]
  |  Branch (912:50): [True: 704, False: 2.01k]
  ------------------
  913|    893|    z->sn = (-1);
  914|  2.37k|  else
  915|  2.37k|    z->sn = 1;
  916|  3.26k|  if (uzero(z))
  ------------------
  |  Branch (916:7): [True: 138, False: 3.12k]
  ------------------
  917|    138|    z->sn = 0;
  918|  3.26k|}
bigint.c:mpz_sub_int:
  328|    734|{
  329|    734|  mpz_t z;
  330|       |
  331|    734|  mpz_init_set_int(mrb, &z, n);
  332|    734|  mpz_sub(mrb, x, y, &z);
  333|    734|  mpz_clear(mrb, &z);
  334|    734|}
bigint.c:mpz_div_2exp:
  834|    769|{
  835|    769|  short sn = x->sn;
  836|    769|  if (e==0)
  ------------------
  |  Branch (836:7): [True: 0, False: 769]
  ------------------
  837|      0|    mpz_set(mrb, z, x);
  838|    769|  else {
  839|    769|    size_t digs = e / DIG_SIZE;
  ------------------
  |  |   16|    769|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|    769|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  840|    769|    size_t bs = e % DIG_SIZE;
  ------------------
  |  |   16|    769|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|    769|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  841|    769|    mpz_t y;
  842|       |
  843|    769|    mpz_init(mrb, &y);
  844|    769|    mpz_realloc(mrb, &y, x->sz-digs);
  845|  5.25k|    for (size_t i=0; i < x->sz-digs; i++)
  ------------------
  |  Branch (845:22): [True: 4.48k, False: 769]
  ------------------
  846|  4.48k|      y.p[i] = x->p[i+digs];
  847|    769|    if (bs) {
  ------------------
  |  Branch (847:9): [True: 687, False: 82]
  ------------------
  848|    687|      urshift(mrb, z, &y, bs);
  849|    687|      mpz_clear(mrb, &y);
  850|    687|    }
  851|     82|    else {
  852|     82|      mpz_move(mrb, z, &y);
  853|     82|    }
  854|    769|    if (uzero(z))
  ------------------
  |  Branch (854:9): [True: 127, False: 642]
  ------------------
  855|    127|      z->sn = 0;
  856|    642|    else {
  857|    642|      z->sn = sn;
  858|    642|    }
  859|    769|  }
  860|    769|}
bigint.c:mpz_mul_2exp:
  808|  2.76k|{
  809|  2.76k|  if (e==0)
  ------------------
  |  Branch (809:7): [True: 0, False: 2.76k]
  ------------------
  810|      0|    mpz_set(mrb, z, x);
  811|  2.76k|  else {
  812|  2.76k|    short sn = x->sn;
  813|  2.76k|    size_t digs = e / DIG_SIZE;
  ------------------
  |  |   16|  2.76k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  2.76k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  814|  2.76k|    size_t bs = e % DIG_SIZE;
  ------------------
  |  |   16|  2.76k|#define DIG_SIZE (MPZ_DIG_SIZE)
  |  |  ------------------
  |  |  |  |   46|  2.76k|#define MPZ_DIG_SIZE 32
  |  |  ------------------
  ------------------
  815|  2.76k|    mpz_t y;
  816|       |
  817|  2.76k|    mpz_init(mrb, &y);
  818|  2.76k|    mpz_realloc(mrb, &y, x->sz+digs);
  819|  5.71k|    for (size_t i=0;i<x->sz;i++)
  ------------------
  |  Branch (819:21): [True: 2.94k, False: 2.76k]
  ------------------
  820|  2.94k|      y.p[i+digs] = x->p[i];
  821|  2.76k|    if (bs) {
  ------------------
  |  Branch (821:9): [True: 2.44k, False: 319]
  ------------------
  822|  2.44k|      ulshift(mrb, z, &y, bs);
  823|  2.44k|      mpz_clear(mrb, &y);
  824|  2.44k|    }
  825|    319|    else {
  826|    319|      mpz_move(mrb, z, &y);
  827|    319|    }
  828|  2.76k|    z->sn = sn;
  829|  2.76k|  }
  830|  2.76k|}

mrb_mruby_binding_gem_init:
  399|  1.74k|{
  400|  1.74k|  struct RClass *binding = mrb_define_class(mrb, "Binding", mrb->object_class);
  401|  1.74k|  MRB_SET_INSTANCE_TT(binding, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  402|  1.74k|  mrb_undef_class_method(mrb, binding, "new");
  403|  1.74k|  mrb_undef_class_method(mrb, binding, "allocate");
  404|       |
  405|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "binding", mrb_f_binding, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  406|       |
  407|  1.74k|  mrb_define_method(mrb, binding, "initialize_copy", binding_initialize_copy, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  408|  1.74k|  mrb_define_method(mrb, binding, "local_variable_defined?", binding_local_variable_defined_p, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  409|  1.74k|  mrb_define_method(mrb, binding, "local_variable_get", binding_local_variable_get, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  410|  1.74k|  mrb_define_method(mrb, binding, "local_variable_set", binding_local_variable_set, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  411|  1.74k|  mrb_define_method(mrb, binding, "local_variables", binding_local_variables, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  412|  1.74k|  mrb_define_method(mrb, binding, "receiver", binding_receiver, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  413|  1.74k|  mrb_define_method(mrb, binding, "source_location", binding_source_location, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  414|  1.74k|  mrb_define_method(mrb, binding, "inspect", mrb_any_to_s, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  415|  1.74k|}
mrb_mruby_binding_gem_final:
  419|  1.74k|{
  420|  1.74k|}

mrb_mruby_class_ext_gem_init:
  142|  1.74k|{
  143|  1.74k|  struct RClass *mod = mrb->module_class;
  144|       |
  145|  1.74k|  mrb_define_method(mrb, mod, "name", mod_name, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  146|  1.74k|  mrb_define_method(mrb, mod, "singleton_class?", mod_singleton_class_p, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  147|  1.74k|  mrb_define_method(mrb, mod, "module_exec", mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
                mrb_define_method(mrb, mod, "module_exec", mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  148|  1.74k|  mrb_define_method(mrb, mod, "class_exec", mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
                mrb_define_method(mrb, mod, "class_exec", mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  149|       |
  150|  1.74k|  struct RClass *cls = mrb->class_class;
  151|  1.74k|  mrb_define_method(mrb, cls, "subclasses", class_subclasses, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  152|  1.74k|  mrb_define_method(mrb, cls, "attached_object", class_attached_object, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  153|  1.74k|}
mrb_mruby_class_ext_gem_final:
  157|  1.74k|{
  158|  1.74k|}

mrb_mruby_cmath_gem_init:
  237|  1.74k|{
  238|  1.74k|  struct RClass *cmath;
  239|  1.74k|  cmath = mrb_define_module(mrb, "CMath");
  240|       |
  241|  1.74k|  mrb_include_module(mrb, cmath, mrb_module_get(mrb, "Math"));
  242|       |
  243|  1.74k|  mrb_define_module_function(mrb, cmath, "sin", cmath_sin, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  244|  1.74k|  mrb_define_module_function(mrb, cmath, "cos", cmath_cos, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  245|  1.74k|  mrb_define_module_function(mrb, cmath, "tan", cmath_tan, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  246|       |
  247|  1.74k|  mrb_define_module_function(mrb, cmath, "asin", cmath_asin, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  248|  1.74k|  mrb_define_module_function(mrb, cmath, "acos", cmath_acos, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  249|  1.74k|  mrb_define_module_function(mrb, cmath, "atan", cmath_atan, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  250|       |
  251|  1.74k|  mrb_define_module_function(mrb, cmath, "sinh", cmath_sinh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  252|  1.74k|  mrb_define_module_function(mrb, cmath, "cosh", cmath_cosh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  253|  1.74k|  mrb_define_module_function(mrb, cmath, "tanh", cmath_tanh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  254|       |
  255|  1.74k|  mrb_define_module_function(mrb, cmath, "asinh", cmath_asinh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  256|  1.74k|  mrb_define_module_function(mrb, cmath, "acosh", cmath_acosh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  257|  1.74k|  mrb_define_module_function(mrb, cmath, "atanh", cmath_atanh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  258|       |
  259|  1.74k|  mrb_define_module_function(mrb, cmath, "exp", cmath_exp, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  260|  1.74k|  mrb_define_module_function(mrb, cmath, "log", cmath_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_module_function(mrb, cmath, "log", cmath_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  261|  1.74k|  mrb_define_module_function(mrb, cmath, "log2", cmath_log2, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  262|  1.74k|  mrb_define_module_function(mrb, cmath, "log10", cmath_log10, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  263|  1.74k|  mrb_define_module_function(mrb, cmath, "sqrt", cmath_sqrt, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  264|  1.74k|}
mrb_mruby_cmath_gem_final:
  268|  1.74k|{
  269|  1.74k|}

mrb_decode_insn:
  338|   595k|{
  339|   595k|  struct mrb_insn_data data = { 0 };
  340|   595k|  if (pc == 0) return data;
  ------------------
  |  Branch (340:7): [True: 0, False: 595k]
  ------------------
  341|   595k|  data.addr = pc;
  342|   595k|  mrb_code insn = READ_B();
  ------------------
  |  |   30|   595k|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|   595k|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
  343|   595k|  uint16_t a = 0;
  344|   595k|  uint16_t b = 0;
  345|   595k|  uint16_t c = 0;
  346|       |
  347|   595k|  switch (insn) {
  ------------------
  |  Branch (347:11): [True: 0, False: 595k]
  ------------------
  348|      0|#define FETCH_Z() /* empty */
  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  350|   595k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|  41.7k|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  |  349|  41.7k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 41.7k, False: 553k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|  1.15k|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  |  349|  1.15k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.15k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|  11.5k|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  349|  11.5k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 11.5k, False: 583k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|  4.43k|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  |  349|  4.43k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 4.43k, False: 590k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|    921|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  |  349|    921|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 921, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|  8.86k|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  |  349|  8.86k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 8.86k, False: 586k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|   174k|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  |  349|   174k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 174k, False: 421k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|  1.88k|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  |  349|  1.88k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.88k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|  1.63k|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  |  349|  1.63k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.63k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  1.35k|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  |  349|  1.35k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.35k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  1.24k|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  |  349|  1.24k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.24k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|  4.36k|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  |  349|  4.36k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 4.36k, False: 591k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|  1.91k|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  |  349|  1.91k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.91k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|  1.03k|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  349|  1.03k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.03k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|  1.52k|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  |  349|  1.52k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.52k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|  4.34k|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  |  349|  4.34k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 4.34k, False: 591k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|  18.7k|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|  18.7k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 18.7k, False: 576k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|  30.4k|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|  30.4k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 30.4k, False: 564k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|  2.75k|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  |  349|  2.75k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 2.75k, False: 592k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    548|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  349|    548|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 548, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|  1.54k|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  349|  1.54k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.54k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|  23.1k|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  349|  23.1k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 23.1k, False: 572k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|  5.97k|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  5.97k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 5.97k, False: 589k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|  3.52k|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  |  349|  3.52k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 3.52k, False: 591k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|  7.34k|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  7.34k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 7.34k, False: 588k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|  2.02k|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  |  349|  2.02k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 2.02k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|  6.62k|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  6.62k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 6.62k, False: 588k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|  3.78k|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  3.78k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 3.78k, False: 591k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|  1.01k|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  1.01k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.01k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|    752|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  |  349|    752|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 752, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|  3.48k|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  3.48k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 3.48k, False: 591k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|    716|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  |  349|    716|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 716, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|  1.13k|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  |  349|  1.13k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.13k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|  50.3k|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  349|  50.3k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 50.3k, False: 545k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|    317|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  349|    317|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 317, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|      0|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|  2.63k|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  |  349|  2.63k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 2.63k, False: 592k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|    257|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  |  349|    257|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 257, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|   163k|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  |  349|   163k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 163k, False: 432k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|  1.09k|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  |  349|  1.09k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.09k, False: 594k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|  1.82k|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  |  349|  1.82k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 1.82k, False: 593k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  |  349|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (349:21): [True: 0, False: 595k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  351|   595k|#undef OPCODE
  352|   595k|  }
  353|   595k|  switch (insn) {
  354|   163k|  case OP_EXT1:
  ------------------
  |  Branch (354:3): [True: 163k, False: 432k]
  ------------------
  355|   163k|    insn = READ_B();
  ------------------
  |  |   30|   163k|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|   163k|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
  356|   163k|    switch (insn) {
  ------------------
  |  Branch (356:13): [True: 0, False: 163k]
  ------------------
  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  358|   163k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|  5.33k|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  |  357|  5.33k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 5.33k, False: 158k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|  1.12k|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  |  357|  1.12k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 1.12k, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|  4.29k|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  357|  4.29k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 4.29k, False: 159k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|  1.99k|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  |  357|  1.99k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 1.99k, False: 161k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|    212|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  |  357|    212|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 212, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|  3.31k|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  |  357|  3.31k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 3.31k, False: 160k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|   126k|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  |  357|   126k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 126k, False: 37.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|  1.43k|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  |  357|  1.43k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 1.43k, False: 161k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|    965|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  |  357|    965|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 965, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|    557|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  |  357|    557|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 557, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|    979|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  |  357|    979|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 979, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|  1.47k|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  |  357|  1.47k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 1.47k, False: 161k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|    602|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  |  357|    602|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 602, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|    850|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  357|    850|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 850, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|    571|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  |  357|    571|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 571, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|    739|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  |  357|    739|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 739, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|  2.26k|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|  2.26k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 2.26k, False: 161k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|  2.34k|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|  2.34k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 2.34k, False: 161k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|    322|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  |  357|    322|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 322, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|     81|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  357|     81|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 81, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|      0|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|  1.78k|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  357|  1.78k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 1.78k, False: 161k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|    467|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    467|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 467, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|    686|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  |  357|    686|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 686, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|    579|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    579|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 579, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|    424|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  |  357|    424|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 424, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|    819|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    819|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 819, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|    362|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    362|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 362, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|    285|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    285|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 285, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|    237|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    237|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 237, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|    121|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    121|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 121, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|    269|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    269|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 269, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|    200|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  |  357|    200|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 200, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|    839|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  357|    839|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 839, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|      1|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  357|      1|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 1, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|      0|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|    601|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  |  357|    601|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 601, False: 162k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|      0|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|      0|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|      0|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|      0|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  |  357|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:21): [True: 0, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  359|   163k|#undef OPCODE
  360|   163k|    }
  361|   163k|    break;
  362|   163k|  case OP_EXT2:
  ------------------
  |  Branch (362:3): [True: 1.09k, False: 594k]
  ------------------
  363|  1.09k|    insn = READ_B();
  ------------------
  |  |   30|  1.09k|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|  1.09k|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
  364|  1.09k|    switch (insn) {
  ------------------
  |  Branch (364:13): [True: 0, False: 1.09k]
  ------------------
  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  366|  1.09k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|    668|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  |  365|    668|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 668, False: 430]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|    265|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  |  365|    265|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 265, False: 833]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|      0|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|      0|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|      0|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|      0|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|      0|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|      0|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|      0|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|      0|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|      0|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|      0|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|      0|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|      0|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|      0|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|      0|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|      0|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|      0|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|      0|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|      0|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|      0|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|      0|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|      0|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|      0|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|      0|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|      0|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|      0|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|      0|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|     91|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  365|     91|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 91, False: 1.00k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|      0|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|      0|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|     74|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  |  365|     74|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 74, False: 1.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|      0|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|      0|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|      0|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|      0|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  |  365|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (365:21): [True: 0, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  367|  1.09k|#undef OPCODE
  368|  1.09k|    }
  369|  1.09k|    break;
  370|  1.82k|  case OP_EXT3:
  ------------------
  |  Branch (370:3): [True: 1.82k, False: 593k]
  ------------------
  371|  1.82k|    insn = READ_B();
  ------------------
  |  |   30|  1.82k|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|  1.82k|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
  372|  1.82k|    switch (insn) {
  ------------------
  |  Branch (372:13): [True: 0, False: 1.82k]
  ------------------
  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  374|  1.82k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|  1.58k|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  |  373|  1.58k|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 1.58k, False: 237]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|    221|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  |  373|    221|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 221, False: 1.60k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|      0|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|      0|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|      0|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|      0|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|      0|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|      0|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|      0|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|      0|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|      0|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|      0|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|      0|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|      0|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|      0|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|      0|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|      0|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|      0|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|      0|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|      0|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|      0|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|      0|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|      0|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|      0|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|      0|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|      0|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|      0|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|      0|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|      1|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  373|      1|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 1, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|      1|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  |  373|      1|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 1, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|      0|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|     14|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  |  373|     14|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 14, False: 1.80k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|      0|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|      0|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|      0|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|      0|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  |  373|      0|#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (373:21): [True: 0, False: 1.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  375|  1.82k|#undef OPCODE
  376|  1.82k|    }
  377|  1.82k|    break;
  378|   429k|  default:
  ------------------
  |  Branch (378:3): [True: 429k, False: 166k]
  ------------------
  379|   429k|    break;
  380|   595k|  }
  381|   595k|  data.insn = insn;
  382|   595k|  data.a = a;
  383|   595k|  data.b = b;
  384|   595k|  data.c = c;
  385|   595k|  return data;
  386|   595k|}
mrb_generate_code:
 4081|  1.73k|{
 4082|  1.73k|  return generate_code(mrb, p, VAL);
  ------------------
  |  |  326|  1.73k|#define VAL    1
  ------------------
 4083|  1.73k|}
codegen.c:generate_code:
 4044|  1.73k|{
 4045|  1.73k|  codegen_scope *scope = scope_new(mrb, 0, 0);
 4046|  1.73k|  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
 4047|  1.73k|  struct mrb_jmpbuf jmpbuf;
 4048|  1.73k|  struct RProc *proc;
 4049|       |
 4050|  1.73k|  mrb->jmp = &jmpbuf;
 4051|       |
 4052|  1.73k|  scope->mrb = mrb;
 4053|  1.73k|  scope->parser = p;
 4054|  1.73k|  scope->filename_sym = p->filename_sym;
 4055|  1.73k|  scope->filename_index = p->current_filename_index;
 4056|       |
 4057|  1.73k|  MRB_TRY(mrb->jmp) {
  ------------------
  |  |   44|  1.73k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  1.73k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 1.73k, False: 0]
  |  |  ------------------
  ------------------
 4058|       |    /* prepare irep */
 4059|  1.73k|    codegen(scope, p->tree, val);
 4060|  1.73k|    proc = mrb_proc_new(mrb, scope->irep);
 4061|  1.73k|    mrb_irep_decref(mrb, scope->irep);
 4062|  1.73k|    mrb_pool_close(scope->mpool);
 4063|  1.73k|    proc->c = NULL;
 4064|  1.73k|    if (mrb->c->cibase && mrb->c->cibase->proc == proc->upper) {
  ------------------
  |  Branch (4064:9): [True: 1.54k, False: 189]
  |  Branch (4064:27): [True: 1.54k, False: 0]
  ------------------
 4065|  1.54k|      proc->upper = NULL;
 4066|  1.54k|    }
 4067|  1.73k|    mrb->jmp = prev_jmp;
 4068|  1.73k|    return proc;
 4069|  1.73k|  }
 4070|  1.73k|  MRB_CATCH(mrb->jmp) {
  ------------------
  |  |   45|  1.73k|#define MRB_CATCH(buf) } else {
  ------------------
 4071|      0|    mrb_irep_decref(mrb, scope->irep);
 4072|      0|    mrb_pool_close(scope->mpool);
 4073|      0|    mrb->jmp = prev_jmp;
 4074|      0|    return NULL;
 4075|      0|  }
 4076|      0|  MRB_END_EXC(mrb->jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
 4077|      0|}
codegen.c:scope_new:
 3824|  5.19k|{
 3825|  5.19k|  static const codegen_scope codegen_scope_zero = { 0 };
 3826|  5.19k|  mrb_pool *pool = mrb_pool_open(mrb);
 3827|  5.19k|  codegen_scope *s = (codegen_scope*)mrb_pool_alloc(pool, sizeof(codegen_scope));
 3828|       |
 3829|  5.19k|  if (!s) {
  ------------------
  |  Branch (3829:7): [True: 0, False: 5.19k]
  ------------------
 3830|      0|    if (prev)
  ------------------
  |  Branch (3830:9): [True: 0, False: 0]
  ------------------
 3831|      0|      codegen_error(prev, "unexpected scope");
 3832|      0|    return NULL;
 3833|      0|  }
 3834|  5.19k|  *s = codegen_scope_zero;
 3835|  5.19k|  s->mrb = mrb;
 3836|  5.19k|  s->mpool = pool;
 3837|  5.19k|  if (!prev) return s;
  ------------------
  |  Branch (3837:7): [True: 1.73k, False: 3.46k]
  ------------------
 3838|  3.46k|  s->prev = prev;
 3839|  3.46k|  s->ainfo = 0;
 3840|  3.46k|  s->mscope = 0;
 3841|       |
 3842|  3.46k|  scope_add_irep(s);
 3843|       |
 3844|  3.46k|  s->rcapa = 8;
 3845|  3.46k|  s->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*s->rcapa);
 3846|       |
 3847|  3.46k|  s->icapa = 1024;
 3848|  3.46k|  s->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*s->icapa);
 3849|       |
 3850|  3.46k|  s->pcapa = 32;
 3851|  3.46k|  s->pool = (mrb_pool_value*)mrb_malloc(mrb, sizeof(mrb_pool_value)*s->pcapa);
 3852|       |
 3853|  3.46k|  s->scapa = 256;
 3854|  3.46k|  s->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*s->scapa);
 3855|       |
 3856|  3.46k|  s->lv = nlv;
 3857|  3.46k|  s->sp += node_len(nlv)+1;        /* add self */
 3858|  3.46k|  s->nlocals = s->sp;
 3859|  3.46k|  if (nlv) {
  ------------------
  |  Branch (3859:7): [True: 1.73k, False: 1.73k]
  ------------------
 3860|  1.73k|    mrb_sym *lv;
 3861|  1.73k|    node *n = nlv;
 3862|  1.73k|    size_t i = 0;
 3863|       |
 3864|  1.73k|    s->irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*(s->nlocals-1));
 3865|   164k|    for (i=0, n=nlv; n; i++,n=n->cdr) {
  ------------------
  |  Branch (3865:22): [True: 162k, False: 1.73k]
  ------------------
 3866|   162k|      lv[i] = lv_name(n);
  ------------------
  |  | 1231|   162k|#define lv_name(lv) nsym((lv)->car)
  |  |  ------------------
  |  |  |  | 1229|   162k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  |  |  ------------------
  ------------------
 3867|   162k|    }
 3868|  1.73k|    mrb_assert(i + 1 == s->nlocals);
  ------------------
  |  |   68|  1.73k|#define mrb_assert(p) ((void)0)
  ------------------
 3869|  1.73k|  }
 3870|  3.46k|  s->ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  3.46k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
 3871|       |
 3872|  3.46k|  s->filename_sym = prev->filename_sym;
 3873|  3.46k|  if (s->filename_sym) {
  ------------------
  |  Branch (3873:7): [True: 0, False: 3.46k]
  ------------------
 3874|      0|    s->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*s->icapa);
 3875|      0|  }
 3876|  3.46k|  s->lineno = prev->lineno;
 3877|       |
 3878|       |  /* debug setting */
 3879|  3.46k|  s->debug_start_pos = 0;
 3880|  3.46k|  if (s->filename_sym) {
  ------------------
  |  Branch (3880:7): [True: 0, False: 3.46k]
  ------------------
 3881|      0|    mrb_debug_info_alloc(mrb, s->irep);
 3882|      0|  }
 3883|  3.46k|  else {
 3884|  3.46k|    s->irep->debug_info = NULL;
 3885|  3.46k|  }
 3886|  3.46k|  s->parser = prev->parser;
 3887|  3.46k|  s->filename_index = prev->filename_index;
 3888|       |
 3889|  3.46k|  s->rlev = prev->rlev+1;
 3890|       |
 3891|  3.46k|  return s;
 3892|  5.19k|}
codegen.c:codegen_error:
  113|    189|{
  114|    189|  if (!s) return;
  ------------------
  |  Branch (114:7): [True: 0, False: 189]
  ------------------
  115|    189|#ifndef MRB_NO_STDIO
  116|    189|  if (s->filename_sym && s->lineno) {
  ------------------
  |  Branch (116:7): [True: 0, False: 189]
  |  Branch (116:26): [True: 0, False: 0]
  ------------------
  117|      0|    const char *filename = mrb_sym_name_len(s->mrb, s->filename_sym, NULL);
  118|      0|    fprintf(stderr, "%s:%d: %s\n", filename, s->lineno, message);
  119|      0|  }
  120|    189|  else {
  121|    189|    fprintf(stderr, "%s\n", message);
  122|    189|  }
  123|    189|#endif
  124|    567|  while (s->prev) {
  ------------------
  |  Branch (124:10): [True: 378, False: 189]
  ------------------
  125|    378|    codegen_scope *tmp = s->prev;
  126|    378|    if (s->irep) {
  ------------------
  |  Branch (126:9): [True: 378, False: 0]
  ------------------
  127|    378|      mrb_free(s->mrb, s->iseq);
  128|  1.87k|      for (int i=0; i<s->irep->plen; i++) {
  ------------------
  |  Branch (128:21): [True: 1.49k, False: 378]
  ------------------
  129|  1.49k|        mrb_pool_value *pv = &s->pool[i];
  130|  1.49k|        if ((pv->tt & 0x3) == IREP_TT_STR || pv->tt == IREP_TT_BIGINT) {
  ------------------
  |  Branch (130:13): [True: 1.15k, False: 342]
  |  Branch (130:46): [True: 0, False: 342]
  ------------------
  131|  1.15k|          mrb_free(s->mrb, (void*)pv->u.str);
  132|  1.15k|        }
  133|  1.49k|      }
  134|    378|      mrb_free(s->mrb, s->pool);
  135|    378|      mrb_free(s->mrb, s->syms);
  136|    378|      mrb_free(s->mrb, s->catch_table);
  137|    378|      if (s->reps) {
  ------------------
  |  Branch (137:11): [True: 378, False: 0]
  ------------------
  138|       |        /* copied from mrb_irep_free() in state.c */
  139|    567|        for (int i=0; i<s->irep->rlen; i++) {
  ------------------
  |  Branch (139:23): [True: 189, False: 378]
  ------------------
  140|    189|          if (s->reps[i])
  ------------------
  |  Branch (140:15): [True: 189, False: 0]
  ------------------
  141|    189|            mrb_irep_decref(s->mrb, (mrb_irep*)s->reps[i]);
  142|    189|        }
  143|    378|        mrb_free(s->mrb, s->reps);
  144|    378|      }
  145|    378|      mrb_free(s->mrb, s->lines);
  146|    378|    }
  147|    378|    mrb_pool_close(s->mpool);
  148|    378|    s = tmp;
  149|    378|  }
  150|    189|  MRB_THROW(s->mrb->jmp);
  ------------------
  |  |   48|    189|#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
  |  |  ------------------
  |  |  |  |   41|    378|#define MRB_LONGJMP longjmp
  |  |  ------------------
  ------------------
  151|      0|}
codegen.c:scope_add_irep:
 3799|  3.46k|{
 3800|  3.46k|  mrb_irep *irep;
 3801|  3.46k|  codegen_scope *prev = s->prev;
 3802|       |
 3803|  3.46k|  if (prev->irep == NULL) {
  ------------------
  |  Branch (3803:7): [True: 1.73k, False: 1.73k]
  ------------------
 3804|  1.73k|    irep = mrb_add_irep(s->mrb);
 3805|  1.73k|    prev->irep = s->irep = irep;
 3806|  1.73k|    return;
 3807|  1.73k|  }
 3808|  1.73k|  else {
 3809|  1.73k|    if (prev->irep->rlen == UINT16_MAX) {
  ------------------
  |  Branch (3809:9): [True: 0, False: 1.73k]
  ------------------
 3810|      0|      codegen_error(s, "too many nested blocks/methods");
 3811|      0|    }
 3812|  1.73k|    s->irep = irep = mrb_add_irep(s->mrb);
 3813|  1.73k|    if (prev->irep->rlen == prev->rcapa) {
  ------------------
  |  Branch (3813:9): [True: 0, False: 1.73k]
  ------------------
 3814|      0|      prev->rcapa *= 2;
 3815|      0|      prev->reps = (mrb_irep**)codegen_realloc(s, prev->reps, sizeof(mrb_irep*)*prev->rcapa);
 3816|      0|    }
 3817|  1.73k|    prev->reps[prev->irep->rlen] = irep;
 3818|  1.73k|    prev->irep->rlen++;
 3819|  1.73k|  }
 3820|  3.46k|}
codegen.c:codegen_realloc:
  164|  32.9k|{
  165|  32.9k|  p = mrb_realloc_simple(s->mrb, p, len);
  166|       |
  167|  32.9k|  if (!p && len > 0) codegen_error(s, "mrb_realloc");
  ------------------
  |  Branch (167:7): [True: 4.06k, False: 28.8k]
  |  Branch (167:13): [True: 0, False: 4.06k]
  ------------------
  168|  32.9k|  return p;
  169|  32.9k|}
codegen.c:node_len:
 1217|  8.65k|{
 1218|  8.65k|  int n = 0;
 1219|       |
 1220|   171k|  while (tree) {
  ------------------
  |  Branch (1220:10): [True: 162k, False: 8.65k]
  ------------------
 1221|   162k|    n++;
 1222|   162k|    tree = tree->cdr;
 1223|   162k|  }
 1224|  8.65k|  return n;
 1225|  8.65k|}
codegen.c:codegen:
 2258|  1.89M|{
 2259|  1.89M|  int nt;
 2260|  1.89M|  int rlev = s->rlev;
 2261|       |
 2262|  1.89M|  if (!tree) {
  ------------------
  |  Branch (2262:7): [True: 0, False: 1.89M]
  ------------------
 2263|      0|    if (val) {
  ------------------
  |  Branch (2263:9): [True: 0, False: 0]
  ------------------
 2264|      0|      genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2265|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2266|      0|    }
 2267|      0|    return;
 2268|      0|  }
 2269|       |
 2270|  1.89M|  s->rlev++;
 2271|  1.89M|  if (s->rlev > MRB_CODEGEN_LEVEL_MAX) {
  ------------------
  |  |   24|  1.89M|#define MRB_CODEGEN_LEVEL_MAX 256
  ------------------
  |  Branch (2271:7): [True: 0, False: 1.89M]
  ------------------
 2272|      0|    codegen_error(s, "too complex expression");
 2273|      0|  }
 2274|  1.89M|  if (s->irep && s->filename_index != tree->filename_index) {
  ------------------
  |  Branch (2274:7): [True: 1.89M, False: 1.73k]
  |  Branch (2274:18): [True: 0, False: 1.89M]
  ------------------
 2275|      0|    mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
 2276|      0|    const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
 2277|       |
 2278|      0|    mrb_debug_info_append_file(s->mrb, s->irep->debug_info,
 2279|      0|                               filename, s->lines, s->debug_start_pos, s->pc);
 2280|      0|    s->debug_start_pos = s->pc;
 2281|      0|    s->filename_index = tree->filename_index;
 2282|      0|    s->filename_sym = mrb_parser_get_filename(s->parser, tree->filename_index);
 2283|      0|  }
 2284|       |
 2285|  1.89M|  nt = nint(tree->car);
  ------------------
  |  | 1227|  1.89M|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 2286|  1.89M|  s->lineno = tree->lineno;
 2287|  1.89M|  tree = tree->cdr;
 2288|  1.89M|  switch (nt) {
 2289|   245k|  case NODE_BEGIN:
  ------------------
  |  Branch (2289:3): [True: 245k, False: 1.65M]
  ------------------
 2290|   245k|    if (val && !tree) {
  ------------------
  |  Branch (2290:9): [True: 214k, False: 30.7k]
  |  Branch (2290:16): [True: 11.8k, False: 202k]
  ------------------
 2291|  11.8k|      genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|  11.8k|#define cursp() (s->sp)
  ------------------
 2292|  11.8k|      push();
  ------------------
  |  |  986|  11.8k|#define push() push_n_(s,1)
  ------------------
 2293|  11.8k|    }
 2294|   819k|    while (tree) {
  ------------------
  |  Branch (2294:12): [True: 574k, False: 245k]
  ------------------
 2295|   574k|      codegen(s, tree->car, tree->cdr ? NOVAL : val);
  ------------------
  |  |  325|   359k|#define NOVAL  0
  ------------------
  |  Branch (2295:29): [True: 359k, False: 214k]
  ------------------
 2296|   574k|      tree = tree->cdr;
 2297|   574k|    }
 2298|   245k|    break;
 2299|       |
 2300|      0|  case NODE_RESCUE:
  ------------------
  |  Branch (2300:3): [True: 0, False: 1.89M]
  ------------------
 2301|      0|    {
 2302|      0|      int noexc;
 2303|      0|      uint32_t exend, pos1, pos2, tmp;
 2304|      0|      struct loopinfo *lp;
 2305|      0|      int catch_entry, begin, end;
 2306|       |
 2307|      0|      if (tree->car == NULL) goto exit;
  ------------------
  |  Branch (2307:11): [True: 0, False: 0]
  ------------------
 2308|      0|      lp = loop_push(s, LOOP_BEGIN);
 2309|      0|      lp->pc0 = new_label(s);
 2310|      0|      catch_entry = catch_handler_new(s);
 2311|      0|      begin = s->pc;
 2312|      0|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2313|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2314|      0|      lp->type = LOOP_RESCUE;
 2315|      0|      end = s->pc;
 2316|      0|      noexc = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2317|      0|      catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
 2318|      0|      tree = tree->cdr;
 2319|      0|      exend = JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
 2320|      0|      pos1 = JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
 2321|      0|      if (tree->car) {
  ------------------
  |  Branch (2321:11): [True: 0, False: 0]
  ------------------
 2322|      0|        node *n2 = tree->car;
 2323|      0|        int exc = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2324|       |
 2325|      0|        genop_1(s, OP_EXCEPT, exc);
 2326|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2327|      0|        while (n2) {
  ------------------
  |  Branch (2327:16): [True: 0, False: 0]
  ------------------
 2328|      0|          node *n3 = n2->car;
 2329|      0|          node *n4 = n3->car;
 2330|       |
 2331|      0|          dispatch(s, pos1);
 2332|      0|          pos2 = JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
 2333|      0|          do {
 2334|      0|            if (n4 && n4->car && nint(n4->car->car) == NODE_SPLAT) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2334:17): [True: 0, False: 0]
  |  Branch (2334:23): [True: 0, False: 0]
  |  Branch (2334:34): [True: 0, False: 0]
  ------------------
 2335|      0|              codegen(s, n4->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2336|      0|              gen_move(s, cursp(), exc, 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2337|      0|              push_n(2); pop_n(2); /* space for one arg and a block */
  ------------------
  |  |  987|      0|#define push_n(n) push_n_(s,n)
  ------------------
                            push_n(2); pop_n(2); /* space for one arg and a block */
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 2338|      0|              pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2339|      0|              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, __case_eqq)), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                            genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, __case_eqq)), 1);
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 2340|      0|            }
 2341|      0|            else {
 2342|      0|              if (n4) {
  ------------------
  |  Branch (2342:19): [True: 0, False: 0]
  ------------------
 2343|      0|                codegen(s, n4->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2344|      0|              }
 2345|      0|              else {
 2346|      0|                genop_2(s, OP_GETCONST, cursp(), new_sym(s, MRB_SYM_2(s->mrb, StandardError)));
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                              genop_2(s, OP_GETCONST, cursp(), new_sym(s, MRB_SYM_2(s->mrb, StandardError)));
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 2347|      0|                push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2348|      0|              }
 2349|      0|              pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2350|      0|              genop_2(s, OP_RESCUE, exc, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2351|      0|            }
 2352|      0|            tmp = genjmp2(s, OP_JMPIF, cursp(), pos2, val);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2353|      0|            pos2 = tmp;
 2354|      0|            if (n4) {
  ------------------
  |  Branch (2354:17): [True: 0, False: 0]
  ------------------
 2355|      0|              n4 = n4->cdr;
 2356|      0|            }
 2357|      0|          } while (n4);
  ------------------
  |  Branch (2357:20): [True: 0, False: 0]
  ------------------
 2358|      0|          pos1 = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2359|      0|          dispatch_linked(s, pos2);
 2360|       |
 2361|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2362|      0|          if (n3->cdr->car) {
  ------------------
  |  Branch (2362:15): [True: 0, False: 0]
  ------------------
 2363|      0|            gen_assignment(s, n3->cdr->car, NULL, exc, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2364|      0|          }
 2365|      0|          if (n3->cdr->cdr->car) {
  ------------------
  |  Branch (2365:15): [True: 0, False: 0]
  ------------------
 2366|      0|            codegen(s, n3->cdr->cdr->car, val);
 2367|      0|            if (val) pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
  |  Branch (2367:17): [True: 0, False: 0]
  ------------------
 2368|      0|          }
 2369|      0|          tmp = genjmp(s, OP_JMP, exend);
 2370|      0|          exend = tmp;
 2371|      0|          n2 = n2->cdr;
 2372|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2373|      0|        }
 2374|      0|        if (pos1 != JMPLINK_START) {
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
  |  Branch (2374:13): [True: 0, False: 0]
  ------------------
 2375|      0|          dispatch(s, pos1);
 2376|      0|          genop_1(s, OP_RAISEIF, exc);
 2377|      0|        }
 2378|      0|      }
 2379|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2380|      0|      tree = tree->cdr;
 2381|      0|      dispatch(s, noexc);
 2382|      0|      if (tree->car) {
  ------------------
  |  Branch (2382:11): [True: 0, False: 0]
  ------------------
 2383|      0|        codegen(s, tree->car, val);
 2384|      0|      }
 2385|      0|      else if (val) {
  ------------------
  |  Branch (2385:16): [True: 0, False: 0]
  ------------------
 2386|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2387|      0|      }
 2388|      0|      dispatch_linked(s, exend);
 2389|      0|      loop_pop(s, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2390|      0|    }
 2391|      0|    break;
 2392|       |
 2393|      0|  case NODE_ENSURE:
  ------------------
  |  Branch (2393:3): [True: 0, False: 1.89M]
  ------------------
 2394|      0|    if (!tree->cdr || !tree->cdr->cdr ||
  ------------------
  |  Branch (2394:9): [True: 0, False: 0]
  |  Branch (2394:23): [True: 0, False: 0]
  ------------------
 2395|      0|        (nint(tree->cdr->cdr->car) == NODE_BEGIN &&
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2395:10): [True: 0, False: 0]
  ------------------
 2396|      0|         tree->cdr->cdr->cdr)) {
  ------------------
  |  Branch (2396:10): [True: 0, False: 0]
  ------------------
 2397|      0|      int catch_entry, begin, end, target;
 2398|      0|      int idx;
 2399|       |
 2400|      0|      catch_entry = catch_handler_new(s);
 2401|      0|      begin = s->pc;
 2402|      0|      codegen(s, tree->car, val);
 2403|      0|      end = target = s->pc;
 2404|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2405|      0|      idx = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2406|      0|      genop_1(s, OP_EXCEPT, idx);
 2407|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2408|      0|      codegen(s, tree->cdr->cdr, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2409|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2410|      0|      genop_1(s, OP_RAISEIF, idx);
 2411|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2412|      0|      catch_handler_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target);
 2413|      0|    }
 2414|      0|    else {                      /* empty ensure ignored */
 2415|      0|      codegen(s, tree->car, val);
 2416|      0|    }
 2417|      0|    break;
 2418|       |
 2419|      0|  case NODE_LAMBDA:
  ------------------
  |  Branch (2419:3): [True: 0, False: 1.89M]
  ------------------
 2420|      0|    if (val) {
  ------------------
  |  Branch (2420:9): [True: 0, False: 0]
  ------------------
 2421|      0|      int idx = lambda_body(s, tree, 1);
 2422|       |
 2423|      0|      genop_2(s, OP_LAMBDA, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2424|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2425|      0|    }
 2426|      0|    break;
 2427|       |
 2428|      0|  case NODE_BLOCK:
  ------------------
  |  Branch (2428:3): [True: 0, False: 1.89M]
  ------------------
 2429|      0|    if (val) {
  ------------------
  |  Branch (2429:9): [True: 0, False: 0]
  ------------------
 2430|      0|      int idx = lambda_body(s, tree, 1);
 2431|       |
 2432|      0|      genop_2(s, OP_BLOCK, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2433|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2434|      0|    }
 2435|      0|    break;
 2436|       |
 2437|  25.8k|  case NODE_IF:
  ------------------
  |  Branch (2437:3): [True: 25.8k, False: 1.87M]
  ------------------
 2438|  25.8k|    {
 2439|  25.8k|      uint32_t pos1, pos2;
 2440|  25.8k|      mrb_bool nil_p = FALSE;
  ------------------
  |  |   51|  25.8k|#  define FALSE 0
  ------------------
 2441|  25.8k|      node *elsepart = tree->cdr->cdr->car;
 2442|       |
 2443|  25.8k|      if (!tree->car) {
  ------------------
  |  Branch (2443:11): [True: 0, False: 25.8k]
  ------------------
 2444|      0|        codegen(s, elsepart, val);
 2445|      0|        goto exit;
 2446|      0|      }
 2447|  25.8k|      if (true_always(tree->car)) {
  ------------------
  |  Branch (2447:11): [True: 11.6k, False: 14.2k]
  ------------------
 2448|  11.6k|        codegen(s, tree->cdr->car, val);
 2449|  11.6k|        goto exit;
 2450|  11.6k|      }
 2451|  14.2k|      if (false_always(tree->car)) {
  ------------------
  |  Branch (2451:11): [True: 0, False: 14.2k]
  ------------------
 2452|      0|        codegen(s, elsepart, val);
 2453|      0|        goto exit;
 2454|      0|      }
 2455|  14.2k|      if (nint(tree->car->car) == NODE_CALL) {
  ------------------
  |  | 1227|  14.2k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2455:11): [True: 0, False: 14.2k]
  ------------------
 2456|      0|        node *n = tree->car->cdr;
 2457|      0|        mrb_sym mid = nsym(n->cdr->car);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2458|      0|        mrb_sym sym_nil_p = MRB_SYM_Q_2(s->mrb, nil);
  ------------------
  |  |   24|      0|#define MRB_SYM_Q_2(mrb, name) MRB_SYM_Q__##name
  ------------------
 2459|      0|        if (mid == sym_nil_p && n->cdr->cdr->car == NULL) {
  ------------------
  |  Branch (2459:13): [True: 0, False: 0]
  |  Branch (2459:33): [True: 0, False: 0]
  ------------------
 2460|      0|          nil_p = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 2461|      0|          codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2462|      0|        }
 2463|      0|      }
 2464|  14.2k|      if (!nil_p) {
  ------------------
  |  Branch (2464:11): [True: 14.2k, False: 0]
  ------------------
 2465|  14.2k|        codegen(s, tree->car, VAL);
  ------------------
  |  |  326|  14.2k|#define VAL    1
  ------------------
 2466|  14.2k|      }
 2467|  14.2k|      pop();
  ------------------
  |  |  988|  14.2k|#define pop() pop_n_(s,1)
  ------------------
 2468|  14.2k|      if (val || tree->cdr->car) {
  ------------------
  |  Branch (2468:11): [True: 3.14k, False: 11.0k]
  |  Branch (2468:18): [True: 11.0k, False: 0]
  ------------------
 2469|  14.2k|        if (nil_p) {
  ------------------
  |  Branch (2469:13): [True: 0, False: 14.2k]
  ------------------
 2470|      0|          pos2 = genjmp2_0(s, OP_JMPNIL, cursp(), val);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2471|      0|          pos1 = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2472|      0|          dispatch(s, pos2);
 2473|      0|        }
 2474|  14.2k|        else {
 2475|  14.2k|          pos1 = genjmp2_0(s, OP_JMPNOT, cursp(), val);
  ------------------
  |  |  583|  14.2k|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|  14.2k|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2476|  14.2k|        }
 2477|  14.2k|        codegen(s, tree->cdr->car, val);
 2478|  14.2k|        if (val) pop();
  ------------------
  |  |  988|  3.14k|#define pop() pop_n_(s,1)
  ------------------
  |  Branch (2478:13): [True: 3.14k, False: 11.0k]
  ------------------
 2479|  14.2k|        if (elsepart || val) {
  ------------------
  |  Branch (2479:13): [True: 14.2k, False: 0]
  |  Branch (2479:25): [True: 0, False: 0]
  ------------------
 2480|  14.2k|          pos2 = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|  14.2k|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|  14.2k|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2481|  14.2k|          dispatch(s, pos1);
 2482|  14.2k|          codegen(s, elsepart, val);
 2483|  14.2k|          dispatch(s, pos2);
 2484|  14.2k|        }
 2485|      0|        else {
 2486|      0|          dispatch(s, pos1);
 2487|      0|        }
 2488|  14.2k|      }
 2489|      0|      else {                    /* empty then-part */
 2490|      0|        if (elsepart) {
  ------------------
  |  Branch (2490:13): [True: 0, False: 0]
  ------------------
 2491|      0|          if (nil_p) {
  ------------------
  |  Branch (2491:15): [True: 0, False: 0]
  ------------------
 2492|      0|            pos1 = genjmp2_0(s, OP_JMPNIL, cursp(), val);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2493|      0|          }
 2494|      0|          else {
 2495|      0|            pos1 = genjmp2_0(s, OP_JMPIF, cursp(), val);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2496|      0|          }
 2497|      0|          codegen(s, elsepart, val);
 2498|      0|          dispatch(s, pos1);
 2499|      0|        }
 2500|      0|        else if (val && !nil_p) {
  ------------------
  |  Branch (2500:18): [True: 0, False: 0]
  |  Branch (2500:25): [True: 0, False: 0]
  ------------------
 2501|      0|          genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2502|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2503|      0|        }
 2504|      0|      }
 2505|  14.2k|    }
 2506|      0|    break;
 2507|       |
 2508|  4.10k|  case NODE_AND:
  ------------------
  |  Branch (2508:3): [True: 4.10k, False: 1.89M]
  ------------------
 2509|  4.10k|    {
 2510|  4.10k|      uint32_t pos;
 2511|       |
 2512|  4.10k|      if (true_always(tree->car)) {
  ------------------
  |  Branch (2512:11): [True: 869, False: 3.23k]
  ------------------
 2513|    869|        codegen(s, tree->cdr, val);
 2514|    869|        goto exit;
 2515|    869|      }
 2516|  3.23k|      if (false_always(tree->car)) {
  ------------------
  |  Branch (2516:11): [True: 0, False: 3.23k]
  ------------------
 2517|      0|        codegen(s, tree->car, val);
 2518|      0|        goto exit;
 2519|      0|      }
 2520|  3.23k|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|  3.23k|#define VAL    1
  ------------------
 2521|  3.23k|      pop();
  ------------------
  |  |  988|  3.23k|#define pop() pop_n_(s,1)
  ------------------
 2522|  3.23k|      pos = genjmp2_0(s, OP_JMPNOT, cursp(), val);
  ------------------
  |  |  583|  3.23k|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|  3.23k|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2523|  3.23k|      codegen(s, tree->cdr, val);
 2524|  3.23k|      dispatch(s, pos);
 2525|  3.23k|    }
 2526|      0|    break;
 2527|       |
 2528|  2.02k|  case NODE_OR:
  ------------------
  |  Branch (2528:3): [True: 2.02k, False: 1.89M]
  ------------------
 2529|  2.02k|    {
 2530|  2.02k|      uint32_t pos;
 2531|       |
 2532|  2.02k|      if (true_always(tree->car)) {
  ------------------
  |  Branch (2532:11): [True: 585, False: 1.44k]
  ------------------
 2533|    585|        codegen(s, tree->car, val);
 2534|    585|        goto exit;
 2535|    585|      }
 2536|  1.44k|      if (false_always(tree->car)) {
  ------------------
  |  Branch (2536:11): [True: 0, False: 1.44k]
  ------------------
 2537|      0|        codegen(s, tree->cdr, val);
 2538|      0|        goto exit;
 2539|      0|      }
 2540|  1.44k|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|  1.44k|#define VAL    1
  ------------------
 2541|  1.44k|      pop();
  ------------------
  |  |  988|  1.44k|#define pop() pop_n_(s,1)
  ------------------
 2542|  1.44k|      pos = genjmp2_0(s, OP_JMPIF, cursp(), val);
  ------------------
  |  |  583|  1.44k|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|  1.44k|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2543|  1.44k|      codegen(s, tree->cdr, val);
 2544|  1.44k|      dispatch(s, pos);
 2545|  1.44k|    }
 2546|      0|    break;
 2547|       |
 2548|      0|  case NODE_WHILE:
  ------------------
  |  Branch (2548:3): [True: 0, False: 1.89M]
  ------------------
 2549|      0|  case NODE_UNTIL:
  ------------------
  |  Branch (2549:3): [True: 0, False: 1.89M]
  ------------------
 2550|      0|    {
 2551|      0|      if (true_always(tree->car)) {
  ------------------
  |  Branch (2551:11): [True: 0, False: 0]
  ------------------
 2552|      0|        if (nt == NODE_UNTIL) {
  ------------------
  |  Branch (2552:13): [True: 0, False: 0]
  ------------------
 2553|      0|          if (val) {
  ------------------
  |  Branch (2553:15): [True: 0, False: 0]
  ------------------
 2554|      0|            genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2555|      0|            push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2556|      0|          }
 2557|      0|          goto exit;
 2558|      0|        }
 2559|      0|      }
 2560|      0|      else if (false_always(tree->car)) {
  ------------------
  |  Branch (2560:16): [True: 0, False: 0]
  ------------------
 2561|      0|        if (nt == NODE_WHILE) {
  ------------------
  |  Branch (2561:13): [True: 0, False: 0]
  ------------------
 2562|      0|          if (val) {
  ------------------
  |  Branch (2562:15): [True: 0, False: 0]
  ------------------
 2563|      0|            genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2564|      0|            push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2565|      0|          }
 2566|      0|          goto exit;
 2567|      0|        }
 2568|      0|      }
 2569|       |
 2570|      0|      uint32_t pos = JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
 2571|      0|      struct loopinfo *lp = loop_push(s, LOOP_NORMAL);
 2572|       |
 2573|      0|      if (!val) lp->reg = -1;
  ------------------
  |  Branch (2573:11): [True: 0, False: 0]
  ------------------
 2574|      0|      lp->pc0 = new_label(s);
 2575|      0|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2576|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2577|      0|      if (nt == NODE_WHILE) {
  ------------------
  |  Branch (2577:11): [True: 0, False: 0]
  ------------------
 2578|      0|        pos = genjmp2_0(s, OP_JMPNOT, cursp(), NOVAL);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2579|      0|      }
 2580|      0|      else {
 2581|      0|        pos = genjmp2_0(s, OP_JMPIF, cursp(), NOVAL);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2582|      0|      }
 2583|      0|      lp->pc1 = new_label(s);
 2584|      0|      codegen(s, tree->cdr, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2585|      0|      genjmp(s, OP_JMP, lp->pc0);
 2586|      0|      dispatch(s, pos);
 2587|      0|      loop_pop(s, val);
 2588|      0|    }
 2589|      0|    break;
 2590|       |
 2591|      0|  case NODE_FOR:
  ------------------
  |  Branch (2591:3): [True: 0, False: 1.89M]
  ------------------
 2592|      0|    for_body(s, tree);
 2593|      0|    if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (2593:9): [True: 0, False: 0]
  ------------------
 2594|      0|    break;
 2595|       |
 2596|      0|  case NODE_CASE:
  ------------------
  |  Branch (2596:3): [True: 0, False: 1.89M]
  ------------------
 2597|      0|    {
 2598|      0|      int head = 0;
 2599|      0|      uint32_t pos1, pos2, pos3, tmp;
 2600|      0|      node *n;
 2601|       |
 2602|      0|      pos3 = JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
 2603|      0|      if (tree->car) {
  ------------------
  |  Branch (2603:11): [True: 0, False: 0]
  ------------------
 2604|      0|        head = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2605|      0|        codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2606|      0|      }
 2607|      0|      tree = tree->cdr;
 2608|      0|      while (tree) {
  ------------------
  |  Branch (2608:14): [True: 0, False: 0]
  ------------------
 2609|      0|        n = tree->car->car;
 2610|      0|        pos1 = pos2 = JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
 2611|      0|        while (n) {
  ------------------
  |  Branch (2611:16): [True: 0, False: 0]
  ------------------
 2612|      0|          codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2613|      0|          if (head) {
  ------------------
  |  Branch (2613:15): [True: 0, False: 0]
  ------------------
 2614|      0|            gen_move(s, cursp(), head, 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2615|      0|            push(); push(); pop(); pop(); pop();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                          push(); push(); pop(); pop(); pop();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                          push(); push(); pop(); pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                          push(); push(); pop(); pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                          push(); push(); pop(); pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2616|      0|            if (nint(n->car->car) == NODE_SPLAT) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2616:17): [True: 0, False: 0]
  ------------------
 2617|      0|              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, __case_eqq)), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                            genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, __case_eqq)), 1);
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 2618|      0|            }
 2619|      0|            else {
 2620|      0|              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_OPSYM_2(s->mrb, eqq)), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                            genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_OPSYM_2(s->mrb, eqq)), 1);
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
 2621|      0|            }
 2622|      0|          }
 2623|      0|          else {
 2624|      0|            pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2625|      0|          }
 2626|      0|          tmp = genjmp2(s, OP_JMPIF, cursp(), pos2, !head);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2627|      0|          pos2 = tmp;
 2628|      0|          n = n->cdr;
 2629|      0|        }
 2630|      0|        if (tree->car->car) {
  ------------------
  |  Branch (2630:13): [True: 0, False: 0]
  ------------------
 2631|      0|          pos1 = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2632|      0|          dispatch_linked(s, pos2);
 2633|      0|        }
 2634|      0|        codegen(s, tree->car->cdr, val);
 2635|      0|        if (val) pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
  |  Branch (2635:13): [True: 0, False: 0]
  ------------------
 2636|      0|        tmp = genjmp(s, OP_JMP, pos3);
 2637|      0|        pos3 = tmp;
 2638|      0|        dispatch(s, pos1);
 2639|      0|        tree = tree->cdr;
 2640|      0|      }
 2641|      0|      if (val) {
  ------------------
  |  Branch (2641:11): [True: 0, False: 0]
  ------------------
 2642|      0|        uint32_t pos = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2643|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2644|      0|        if (pos3 != JMPLINK_START) dispatch_linked(s, pos3);
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
  |  Branch (2644:13): [True: 0, False: 0]
  ------------------
 2645|      0|        if (head) pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
  |  Branch (2645:13): [True: 0, False: 0]
  ------------------
 2646|      0|        if (cursp() != pos) {
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
  |  Branch (2646:13): [True: 0, False: 0]
  ------------------
 2647|      0|          gen_move(s, cursp(), pos, 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2648|      0|        }
 2649|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2650|      0|      }
 2651|      0|      else {
 2652|      0|        if (pos3 != JMPLINK_START) {
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
  |  Branch (2652:13): [True: 0, False: 0]
  ------------------
 2653|      0|          dispatch_linked(s, pos3);
 2654|      0|        }
 2655|      0|        if (head) {
  ------------------
  |  Branch (2655:13): [True: 0, False: 0]
  ------------------
 2656|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2657|      0|        }
 2658|      0|      }
 2659|      0|    }
 2660|      0|    break;
 2661|       |
 2662|  1.73k|  case NODE_SCOPE:
  ------------------
  |  Branch (2662:3): [True: 1.73k, False: 1.89M]
  ------------------
 2663|  1.73k|    scope_body(s, tree, NOVAL);
  ------------------
  |  |  325|  1.73k|#define NOVAL  0
  ------------------
 2664|  1.73k|    break;
 2665|       |
 2666|  1.54k|  case NODE_FCALL:
  ------------------
  |  Branch (2666:3): [True: 1.54k, False: 1.89M]
  ------------------
 2667|   220k|  case NODE_CALL:
  ------------------
  |  Branch (2667:3): [True: 219k, False: 1.67M]
  ------------------
 2668|   220k|    gen_call(s, tree, val, 0);
 2669|   220k|    break;
 2670|      0|  case NODE_SCALL:
  ------------------
  |  Branch (2670:3): [True: 0, False: 1.89M]
  ------------------
 2671|      0|    gen_call(s, tree, val, 1);
 2672|      0|    break;
 2673|       |
 2674|      0|  case NODE_DOT2:
  ------------------
  |  Branch (2674:3): [True: 0, False: 1.89M]
  ------------------
 2675|      0|    codegen(s, tree->car, val);
 2676|      0|    codegen(s, tree->cdr, val);
 2677|      0|    if (val) {
  ------------------
  |  Branch (2677:9): [True: 0, False: 0]
  ------------------
 2678|      0|      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                    pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2679|      0|      genop_1(s, OP_RANGE_INC, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2680|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2681|      0|    }
 2682|      0|    break;
 2683|       |
 2684|      0|  case NODE_DOT3:
  ------------------
  |  Branch (2684:3): [True: 0, False: 1.89M]
  ------------------
 2685|      0|    codegen(s, tree->car, val);
 2686|      0|    codegen(s, tree->cdr, val);
 2687|      0|    if (val) {
  ------------------
  |  Branch (2687:9): [True: 0, False: 0]
  ------------------
 2688|      0|      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                    pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2689|      0|      genop_1(s, OP_RANGE_EXC, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2690|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2691|      0|    }
 2692|      0|    break;
 2693|       |
 2694|  3.07k|  case NODE_COLON2:
  ------------------
  |  Branch (2694:3): [True: 3.07k, False: 1.89M]
  ------------------
 2695|  3.07k|    {
 2696|  3.07k|      int sym = new_sym(s, nsym(tree->cdr));
  ------------------
  |  | 1229|  3.07k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2697|       |
 2698|  3.07k|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|  3.07k|#define VAL    1
  ------------------
 2699|  3.07k|      pop();
  ------------------
  |  |  988|  3.07k|#define pop() pop_n_(s,1)
  ------------------
 2700|  3.07k|      genop_2(s, OP_GETMCNST, cursp(), sym);
  ------------------
  |  |  990|  3.07k|#define cursp() (s->sp)
  ------------------
 2701|  3.07k|      if (val) push();
  ------------------
  |  |  986|  3.07k|#define push() push_n_(s,1)
  ------------------
  |  Branch (2701:11): [True: 3.07k, False: 0]
  ------------------
 2702|  3.07k|    }
 2703|  3.07k|    break;
 2704|       |
 2705|      0|  case NODE_COLON3:
  ------------------
  |  Branch (2705:3): [True: 0, False: 1.89M]
  ------------------
 2706|      0|    {
 2707|      0|      int sym = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2708|       |
 2709|      0|      genop_1(s, OP_OCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2710|      0|      genop_2(s, OP_GETMCNST, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2711|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (2711:11): [True: 0, False: 0]
  ------------------
 2712|      0|    }
 2713|      0|    break;
 2714|       |
 2715|  55.7k|  case NODE_ARRAY:
  ------------------
  |  Branch (2715:3): [True: 55.7k, False: 1.84M]
  ------------------
 2716|  55.7k|    {
 2717|  55.7k|      int n;
 2718|       |
 2719|  55.7k|      n = gen_values(s, tree, val, 0);
 2720|  55.7k|      if (val) {
  ------------------
  |  Branch (2720:11): [True: 55.7k, False: 0]
  ------------------
 2721|  55.7k|        if (n >= 0) {
  ------------------
  |  Branch (2721:13): [True: 55.1k, False: 515]
  ------------------
 2722|  55.1k|          pop_n(n);
  ------------------
  |  |  989|  55.1k|#define pop_n(n) pop_n_(s,n)
  ------------------
 2723|  55.1k|          genop_2(s, OP_ARRAY, cursp(), n);
  ------------------
  |  |  990|  55.1k|#define cursp() (s->sp)
  ------------------
 2724|  55.1k|        }
 2725|  55.7k|        push();
  ------------------
  |  |  986|  55.7k|#define push() push_n_(s,1)
  ------------------
 2726|  55.7k|      }
 2727|  55.7k|    }
 2728|  55.7k|    break;
 2729|       |
 2730|  3.58k|  case NODE_HASH:
  ------------------
  |  Branch (2730:3): [True: 3.58k, False: 1.89M]
  ------------------
 2731|  3.58k|  case NODE_KW_HASH:
  ------------------
  |  Branch (2731:3): [True: 0, False: 1.89M]
  ------------------
 2732|  3.58k|    {
 2733|  3.58k|      int nk = gen_hash(s, tree, val, GEN_LIT_ARY_MAX);
  ------------------
  |  | 1569|  3.58k|#define GEN_LIT_ARY_MAX 64
  ------------------
 2734|  3.58k|      if (val && nk >= 0) {
  ------------------
  |  Branch (2734:11): [True: 3.58k, False: 0]
  |  Branch (2734:18): [True: 3.03k, False: 547]
  ------------------
 2735|  3.03k|        pop_n(nk*2);
  ------------------
  |  |  989|  3.03k|#define pop_n(n) pop_n_(s,n)
  ------------------
 2736|  3.03k|        genop_2(s, OP_HASH, cursp(), nk);
  ------------------
  |  |  990|  3.03k|#define cursp() (s->sp)
  ------------------
 2737|  3.03k|        push();
  ------------------
  |  |  986|  3.03k|#define push() push_n_(s,1)
  ------------------
 2738|  3.03k|      }
 2739|  3.58k|    }
 2740|  3.58k|    break;
 2741|       |
 2742|      0|  case NODE_SPLAT:
  ------------------
  |  Branch (2742:3): [True: 0, False: 1.89M]
  ------------------
 2743|      0|    codegen(s, tree, val);
 2744|      0|    break;
 2745|       |
 2746|   213k|  case NODE_ASGN:
  ------------------
  |  Branch (2746:3): [True: 213k, False: 1.68M]
  ------------------
 2747|   213k|    gen_assignment(s, tree->car, tree->cdr, 0, val);
 2748|   213k|    break;
 2749|       |
 2750|      0|  case NODE_MASGN:
  ------------------
  |  Branch (2750:3): [True: 0, False: 1.89M]
  ------------------
 2751|      0|    {
 2752|      0|      int len = 0, n = 0, post = 0;
 2753|      0|      node *t = tree->cdr, *p;
 2754|      0|      int rhs = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2755|       |
 2756|      0|      if (!val && nint(t->car) == NODE_ARRAY && t->cdr && nosplat(t->cdr)) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2756:11): [True: 0, False: 0]
  |  Branch (2756:19): [True: 0, False: 0]
  |  Branch (2756:49): [True: 0, False: 0]
  |  Branch (2756:59): [True: 0, False: 0]
  ------------------
 2757|       |        /* fixed rhs */
 2758|      0|        t = t->cdr;
 2759|      0|        while (t) {
  ------------------
  |  Branch (2759:16): [True: 0, False: 0]
  ------------------
 2760|      0|          codegen(s, t->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2761|      0|          len++;
 2762|      0|          t = t->cdr;
 2763|      0|        }
 2764|      0|        tree = tree->car;
 2765|      0|        if (tree->car) {                /* pre */
  ------------------
  |  Branch (2765:13): [True: 0, False: 0]
  ------------------
 2766|      0|          t = tree->car;
 2767|      0|          n = 0;
 2768|      0|          while (t) {
  ------------------
  |  Branch (2768:18): [True: 0, False: 0]
  ------------------
 2769|      0|            if (n < len) {
  ------------------
  |  Branch (2769:17): [True: 0, False: 0]
  ------------------
 2770|      0|              gen_assignment(s, t->car, NULL, rhs+n, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2771|      0|              n++;
 2772|      0|            }
 2773|      0|            else {
 2774|      0|              genop_1(s, OP_LOADNIL, rhs+n);
 2775|      0|              gen_assignment(s, t->car, NULL, rhs+n, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2776|      0|            }
 2777|      0|            t = t->cdr;
 2778|      0|          }
 2779|      0|        }
 2780|      0|        t = tree->cdr;
 2781|      0|        if (t) {
  ------------------
  |  Branch (2781:13): [True: 0, False: 0]
  ------------------
 2782|      0|          if (t->cdr) {         /* post count */
  ------------------
  |  Branch (2782:15): [True: 0, False: 0]
  ------------------
 2783|      0|            p = t->cdr->car;
 2784|      0|            while (p) {
  ------------------
  |  Branch (2784:20): [True: 0, False: 0]
  ------------------
 2785|      0|              post++;
 2786|      0|              p = p->cdr;
 2787|      0|            }
 2788|      0|          }
 2789|      0|          if (t->car) {         /* rest (len - pre - post) */
  ------------------
  |  Branch (2789:15): [True: 0, False: 0]
  ------------------
 2790|      0|            int rn;
 2791|       |
 2792|      0|            if (len < post + n) {
  ------------------
  |  Branch (2792:17): [True: 0, False: 0]
  ------------------
 2793|      0|              rn = 0;
 2794|      0|            }
 2795|      0|            else {
 2796|      0|              rn = len - post - n;
 2797|      0|            }
 2798|      0|            if (cursp() == rhs+n) {
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
  |  Branch (2798:17): [True: 0, False: 0]
  ------------------
 2799|      0|              genop_2(s, OP_ARRAY, cursp(), rn);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2800|      0|            }
 2801|      0|            else {
 2802|      0|              genop_3(s, OP_ARRAY2, cursp(), rhs+n, rn);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2803|      0|            }
 2804|      0|            gen_assignment(s, t->car, NULL, cursp(), NOVAL);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                          gen_assignment(s, t->car, NULL, cursp(), NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2805|      0|            n += rn;
 2806|      0|          }
 2807|      0|          if (t->cdr && t->cdr->car) {
  ------------------
  |  Branch (2807:15): [True: 0, False: 0]
  |  Branch (2807:25): [True: 0, False: 0]
  ------------------
 2808|      0|            t = t->cdr->car;
 2809|      0|            while (t) {
  ------------------
  |  Branch (2809:20): [True: 0, False: 0]
  ------------------
 2810|      0|              if (n<len) {
  ------------------
  |  Branch (2810:19): [True: 0, False: 0]
  ------------------
 2811|      0|                gen_assignment(s, t->car, NULL, rhs+n, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2812|      0|              }
 2813|      0|              else {
 2814|      0|                genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2815|      0|                gen_assignment(s, t->car, NULL, cursp(), NOVAL);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                              gen_assignment(s, t->car, NULL, cursp(), NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2816|      0|              }
 2817|      0|              t = t->cdr;
 2818|      0|              n++;
 2819|      0|            }
 2820|      0|          }
 2821|      0|        }
 2822|      0|        pop_n(len);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 2823|      0|      }
 2824|      0|      else {
 2825|       |        /* variable rhs */
 2826|      0|        codegen(s, t, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2827|      0|        gen_massignment(s, tree->car, rhs, val);
 2828|      0|        if (!val) {
  ------------------
  |  Branch (2828:13): [True: 0, False: 0]
  ------------------
 2829|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2830|      0|        }
 2831|      0|      }
 2832|      0|    }
 2833|      0|    break;
 2834|       |
 2835|  30.8k|  case NODE_OP_ASGN:
  ------------------
  |  Branch (2835:3): [True: 30.8k, False: 1.86M]
  ------------------
 2836|  30.8k|    {
 2837|  30.8k|      mrb_sym sym = nsym(tree->cdr->car);
  ------------------
  |  | 1229|  30.8k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2838|  30.8k|      mrb_int len;
 2839|  30.8k|      const char *name = mrb_sym_name_len(s->mrb, sym, &len);
 2840|  30.8k|      int idx, callargs = -1, vsp = -1;
 2841|       |
 2842|  30.8k|      if ((len == 2 && name[0] == '|' && name[1] == '|') &&
  ------------------
  |  Branch (2842:12): [True: 30.8k, False: 0]
  |  Branch (2842:24): [True: 30.8k, False: 0]
  |  Branch (2842:42): [True: 30.8k, False: 0]
  ------------------
 2843|  30.8k|          (nint(tree->car->car) == NODE_CONST ||
  ------------------
  |  | 1227|  30.8k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2843:12): [True: 0, False: 30.8k]
  ------------------
 2844|  30.8k|           nint(tree->car->car) == NODE_CVAR)) {
  ------------------
  |  | 1227|  30.8k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2844:12): [True: 0, False: 30.8k]
  ------------------
 2845|      0|        int catch_entry, begin, end;
 2846|      0|        int noexc, exc;
 2847|      0|        struct loopinfo *lp;
 2848|       |
 2849|      0|        lp = loop_push(s, LOOP_BEGIN);
 2850|      0|        lp->pc0 = new_label(s);
 2851|      0|        catch_entry = catch_handler_new(s);
 2852|      0|        begin = s->pc;
 2853|      0|        exc = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2854|      0|        codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2855|      0|        end = s->pc;
 2856|      0|        noexc = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 2857|      0|        lp->type = LOOP_RESCUE;
 2858|      0|        catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
 2859|      0|        genop_1(s, OP_EXCEPT, exc);
 2860|      0|        genop_1(s, OP_LOADF, exc);
 2861|      0|        dispatch(s, noexc);
 2862|      0|        loop_pop(s, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 2863|      0|      }
 2864|  30.8k|      else if (nint(tree->car->car) == NODE_CALL) {
  ------------------
  |  | 1227|  30.8k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2864:16): [True: 0, False: 30.8k]
  ------------------
 2865|      0|        node *n = tree->car->cdr;
 2866|      0|        int base, i, nargs = 0;
 2867|      0|        callargs = 0;
 2868|       |
 2869|      0|        if (val) {
  ------------------
  |  Branch (2869:13): [True: 0, False: 0]
  ------------------
 2870|      0|          vsp = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2871|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2872|      0|        }
 2873|      0|        codegen(s, n->car, VAL);   /* receiver */
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2874|      0|        idx = new_sym(s, nsym(n->cdr->car));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2875|      0|        base = cursp()-1;
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2876|      0|        if (n->cdr->cdr->car) {
  ------------------
  |  Branch (2876:13): [True: 0, False: 0]
  ------------------
 2877|      0|          nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 13);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2878|      0|          if (nargs >= 0) {
  ------------------
  |  Branch (2878:15): [True: 0, False: 0]
  ------------------
 2879|      0|            callargs = nargs;
 2880|      0|          }
 2881|      0|          else { /* varargs */
 2882|      0|            push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2883|      0|            nargs = 1;
 2884|      0|            callargs = CALL_MAXARGS;
  ------------------
  |  | 1568|      0|#define CALL_MAXARGS 15
  ------------------
 2885|      0|          }
 2886|      0|        }
 2887|       |        /* copy receiver and arguments */
 2888|      0|        gen_move(s, cursp(), base, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2889|      0|        for (i=0; i<nargs; i++) {
  ------------------
  |  Branch (2889:19): [True: 0, False: 0]
  ------------------
 2890|      0|          gen_move(s, cursp()+i+1, base+i+1, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2891|      0|        }
 2892|      0|        push_n(nargs+2);pop_n(nargs+2); /* space for receiver, arguments and a block */
  ------------------
  |  |  987|      0|#define push_n(n) push_n_(s,n)
  ------------------
                      push_n(nargs+2);pop_n(nargs+2); /* space for receiver, arguments and a block */
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 2893|      0|        genop_3(s, OP_SEND, cursp(), idx, callargs);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2894|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2895|      0|      }
 2896|  30.8k|      else {
 2897|  30.8k|        codegen(s, tree->car, VAL);
  ------------------
  |  |  326|  30.8k|#define VAL    1
  ------------------
 2898|  30.8k|      }
 2899|  30.8k|      if (len == 2 &&
  ------------------
  |  Branch (2899:11): [True: 30.8k, False: 0]
  ------------------
 2900|  30.8k|          ((name[0] == '|' && name[1] == '|') ||
  ------------------
  |  Branch (2900:13): [True: 30.8k, False: 0]
  |  Branch (2900:31): [True: 30.8k, False: 0]
  ------------------
 2901|  30.8k|           (name[0] == '&' && name[1] == '&'))) {
  ------------------
  |  Branch (2901:13): [True: 0, False: 0]
  |  Branch (2901:31): [True: 0, False: 0]
  ------------------
 2902|  30.8k|        uint32_t pos;
 2903|       |
 2904|  30.8k|        pop();
  ------------------
  |  |  988|  30.8k|#define pop() pop_n_(s,1)
  ------------------
 2905|  30.8k|        if (val) {
  ------------------
  |  Branch (2905:13): [True: 9.77k, False: 21.0k]
  ------------------
 2906|  9.77k|          if (vsp >= 0) {
  ------------------
  |  Branch (2906:15): [True: 0, False: 9.77k]
  ------------------
 2907|      0|            gen_move(s, vsp, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2908|      0|          }
 2909|  9.77k|          pos = genjmp2_0(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), val);
  ------------------
  |  |  583|  19.5k|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|  9.77k|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  |  |  |  Branch (583:40): [True: 9.77k, False: 0]
  |  |  ------------------
  ------------------
 2910|  9.77k|        }
 2911|  21.0k|        else {
 2912|  21.0k|          pos = genjmp2_0(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), val);
  ------------------
  |  |  583|  42.0k|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|  21.0k|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  |  |  |  Branch (583:40): [True: 21.0k, False: 0]
  |  |  ------------------
  ------------------
 2913|  21.0k|        }
 2914|  30.8k|        codegen(s, tree->cdr->cdr->car, VAL);
  ------------------
  |  |  326|  30.8k|#define VAL    1
  ------------------
 2915|  30.8k|        pop();
  ------------------
  |  |  988|  30.8k|#define pop() pop_n_(s,1)
  ------------------
 2916|  30.8k|        if (val && vsp >= 0) {
  ------------------
  |  Branch (2916:13): [True: 9.77k, False: 21.0k]
  |  Branch (2916:20): [True: 0, False: 9.77k]
  ------------------
 2917|      0|          gen_move(s, vsp, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2918|      0|        }
 2919|  30.8k|        if (nint(tree->car->car) == NODE_CALL) {
  ------------------
  |  | 1227|  30.8k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (2919:13): [True: 0, False: 30.8k]
  ------------------
 2920|      0|          if (callargs == CALL_MAXARGS) {
  ------------------
  |  | 1568|      0|#define CALL_MAXARGS 15
  ------------------
  |  Branch (2920:15): [True: 0, False: 0]
  ------------------
 2921|      0|            pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2922|      0|            genop_2(s, OP_ARYPUSH, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2923|      0|          }
 2924|      0|          else {
 2925|      0|            pop_n(callargs);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 2926|      0|            callargs++;
 2927|      0|          }
 2928|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2929|      0|          idx = new_sym(s, attrsym(s, nsym(tree->car->cdr->cdr->car)));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2930|      0|          genop_3(s, OP_SEND, cursp(), idx, callargs);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2931|      0|        }
 2932|  30.8k|        else {
 2933|  30.8k|          gen_assignment(s, tree->car, NULL, cursp(), val);
  ------------------
  |  |  990|  30.8k|#define cursp() (s->sp)
  ------------------
 2934|  30.8k|        }
 2935|  30.8k|        dispatch(s, pos);
 2936|  30.8k|        goto exit;
 2937|  30.8k|      }
 2938|      0|      codegen(s, tree->cdr->cdr->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 2939|      0|      push(); pop();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                    push(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2940|      0|      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                    pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2941|       |
 2942|      0|      if (len == 1 && name[0] == '+')  {
  ------------------
  |  Branch (2942:11): [True: 0, False: 0]
  |  Branch (2942:23): [True: 0, False: 0]
  ------------------
 2943|      0|        gen_addsub(s, OP_ADD, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2944|      0|      }
 2945|      0|      else if (len == 1 && name[0] == '-')  {
  ------------------
  |  Branch (2945:16): [True: 0, False: 0]
  |  Branch (2945:28): [True: 0, False: 0]
  ------------------
 2946|      0|        gen_addsub(s, OP_SUB, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2947|      0|      }
 2948|      0|      else if (len == 1 && name[0] == '*')  {
  ------------------
  |  Branch (2948:16): [True: 0, False: 0]
  |  Branch (2948:28): [True: 0, False: 0]
  ------------------
 2949|      0|        genop_1(s, OP_MUL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2950|      0|      }
 2951|      0|      else if (len == 1 && name[0] == '/')  {
  ------------------
  |  Branch (2951:16): [True: 0, False: 0]
  |  Branch (2951:28): [True: 0, False: 0]
  ------------------
 2952|      0|        genop_1(s, OP_DIV, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2953|      0|      }
 2954|      0|      else if (len == 1 && name[0] == '<')  {
  ------------------
  |  Branch (2954:16): [True: 0, False: 0]
  |  Branch (2954:28): [True: 0, False: 0]
  ------------------
 2955|      0|        genop_1(s, OP_LT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2956|      0|      }
 2957|      0|      else if (len == 2 && name[0] == '<' && name[1] == '=')  {
  ------------------
  |  Branch (2957:16): [True: 0, False: 0]
  |  Branch (2957:28): [True: 0, False: 0]
  |  Branch (2957:46): [True: 0, False: 0]
  ------------------
 2958|      0|        genop_1(s, OP_LE, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2959|      0|      }
 2960|      0|      else if (len == 1 && name[0] == '>')  {
  ------------------
  |  Branch (2960:16): [True: 0, False: 0]
  |  Branch (2960:28): [True: 0, False: 0]
  ------------------
 2961|      0|        genop_1(s, OP_GT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2962|      0|      }
 2963|      0|      else if (len == 2 && name[0] == '>' && name[1] == '=')  {
  ------------------
  |  Branch (2963:16): [True: 0, False: 0]
  |  Branch (2963:28): [True: 0, False: 0]
  |  Branch (2963:46): [True: 0, False: 0]
  ------------------
 2964|      0|        genop_1(s, OP_GE, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2965|      0|      }
 2966|      0|      else {
 2967|      0|        idx = new_sym(s, sym);
 2968|      0|        genop_3(s, OP_SEND, cursp(), idx, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2969|      0|      }
 2970|      0|      if (callargs < 0) {
  ------------------
  |  Branch (2970:11): [True: 0, False: 0]
  ------------------
 2971|      0|        gen_assignment(s, tree->car, NULL, cursp(), val);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2972|      0|      }
 2973|      0|      else {
 2974|      0|        if (val && vsp >= 0) {
  ------------------
  |  Branch (2974:13): [True: 0, False: 0]
  |  Branch (2974:20): [True: 0, False: 0]
  ------------------
 2975|      0|          gen_move(s, vsp, cursp(), 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2976|      0|        }
 2977|      0|        if (callargs == CALL_MAXARGS) {
  ------------------
  |  | 1568|      0|#define CALL_MAXARGS 15
  ------------------
  |  Branch (2977:13): [True: 0, False: 0]
  ------------------
 2978|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2979|      0|          genop_2(s, OP_ARYPUSH, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2980|      0|        }
 2981|      0|        else {
 2982|      0|          pop_n(callargs);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 2983|      0|          callargs++;
 2984|      0|        }
 2985|      0|        pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 2986|      0|        idx = new_sym(s, attrsym(s,nsym(tree->car->cdr->cdr->car)));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 2987|      0|        genop_3(s, OP_SEND, cursp(), idx, callargs);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 2988|      0|      }
 2989|      0|    }
 2990|      0|    break;
 2991|       |
 2992|      0|  case NODE_SUPER:
  ------------------
  |  Branch (2992:3): [True: 0, False: 1.89M]
  ------------------
 2993|      0|    {
 2994|      0|      codegen_scope *s2 = s;
 2995|      0|      int lv = 0;
 2996|      0|      int n = 0, nk = 0, st = 0;
 2997|       |
 2998|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 2999|      0|      while (!s2->mscope) {
  ------------------
  |  Branch (2999:14): [True: 0, False: 0]
  ------------------
 3000|      0|        lv++;
 3001|      0|        s2 = s2->prev;
 3002|      0|        if (!s2) break;
  ------------------
  |  Branch (3002:13): [True: 0, False: 0]
  ------------------
 3003|      0|      }
 3004|      0|      if (tree) {
  ------------------
  |  Branch (3004:11): [True: 0, False: 0]
  ------------------
 3005|      0|        node *args = tree->car;
 3006|      0|        if (args) {
  ------------------
  |  Branch (3006:13): [True: 0, False: 0]
  ------------------
 3007|      0|          st = n = gen_values(s, args, VAL, 14);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3008|      0|          if (n < 0) {
  ------------------
  |  Branch (3008:15): [True: 0, False: 0]
  ------------------
 3009|      0|            st = 1; n = 15;
 3010|      0|            push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3011|      0|          }
 3012|      0|        }
 3013|       |        /* keyword arguments */
 3014|      0|        if (tree->cdr->car) {
  ------------------
  |  Branch (3014:13): [True: 0, False: 0]
  ------------------
 3015|      0|          nk = gen_hash(s, tree->cdr->car->cdr, VAL, 14);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3016|      0|          if (nk < 0) {st++; nk = 15;}
  ------------------
  |  Branch (3016:15): [True: 0, False: 0]
  ------------------
 3017|      0|          else st += nk*2;
 3018|      0|          n |= nk<<4;
 3019|      0|        }
 3020|       |        /* block arguments */
 3021|      0|        if (tree->cdr->cdr) {
  ------------------
  |  Branch (3021:13): [True: 0, False: 0]
  ------------------
 3022|      0|          codegen(s, tree->cdr->cdr, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3023|      0|        }
 3024|      0|        else if (s2) gen_blkmove(s, s2->ainfo, lv);
  ------------------
  |  Branch (3024:18): [True: 0, False: 0]
  ------------------
 3025|      0|        else {
 3026|      0|          genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3027|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3028|      0|        }
 3029|      0|      }
 3030|      0|      else {
 3031|      0|        if (s2) gen_blkmove(s, s2->ainfo, lv);
  ------------------
  |  Branch (3031:13): [True: 0, False: 0]
  ------------------
 3032|      0|        else {
 3033|      0|          genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3034|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3035|      0|        }
 3036|      0|      }
 3037|      0|      st++;
 3038|      0|      pop_n(st+1);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3039|      0|      genop_2(s, OP_SUPER, cursp(), n);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3040|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3040:11): [True: 0, False: 0]
  ------------------
 3041|      0|    }
 3042|      0|    break;
 3043|       |
 3044|      0|  case NODE_ZSUPER:
  ------------------
  |  Branch (3044:3): [True: 0, False: 1.89M]
  ------------------
 3045|      0|    {
 3046|      0|      codegen_scope *s2 = s;
 3047|      0|      int lv = 0;
 3048|      0|      uint16_t ainfo = 0;
 3049|      0|      int n = CALL_MAXARGS;
  ------------------
  |  | 1568|      0|#define CALL_MAXARGS 15
  ------------------
 3050|      0|      int sp = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3051|       |
 3052|      0|      push();        /* room for receiver */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3053|      0|      while (!s2->mscope) {
  ------------------
  |  Branch (3053:14): [True: 0, False: 0]
  ------------------
 3054|      0|        lv++;
 3055|      0|        s2 = s2->prev;
 3056|      0|        if (!s2) break;
  ------------------
  |  Branch (3056:13): [True: 0, False: 0]
  ------------------
 3057|      0|      }
 3058|      0|      if (s2 && s2->ainfo > 0) {
  ------------------
  |  Branch (3058:11): [True: 0, False: 0]
  |  Branch (3058:17): [True: 0, False: 0]
  ------------------
 3059|      0|        ainfo = s2->ainfo;
 3060|      0|      }
 3061|      0|      if (ainfo > 0) {
  ------------------
  |  Branch (3061:11): [True: 0, False: 0]
  ------------------
 3062|      0|        genop_2S(s, OP_ARGARY, cursp(), (ainfo<<4)|(lv & 0xf));
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3063|      0|        push(); push(); push();   /* ARGARY pushes 3 values at most */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                      push(); push(); push();   /* ARGARY pushes 3 values at most */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                      push(); push(); push();   /* ARGARY pushes 3 values at most */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3064|      0|        pop(); pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                      pop(); pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                      pop(); pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3065|       |        /* keyword arguments */
 3066|      0|        if (ainfo & 0x1) {
  ------------------
  |  Branch (3066:13): [True: 0, False: 0]
  ------------------
 3067|      0|          n |= CALL_MAXARGS<<4;
  ------------------
  |  | 1568|      0|#define CALL_MAXARGS 15
  ------------------
 3068|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3069|      0|        }
 3070|       |        /* block argument */
 3071|      0|        if (tree && tree->cdr && tree->cdr->cdr) {
  ------------------
  |  Branch (3071:13): [True: 0, False: 0]
  |  Branch (3071:21): [True: 0, False: 0]
  |  Branch (3071:34): [True: 0, False: 0]
  ------------------
 3072|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3073|      0|          codegen(s, tree->cdr->cdr, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3074|      0|        }
 3075|      0|      }
 3076|      0|      else {
 3077|       |        /* block argument */
 3078|      0|        if (tree && tree->cdr && tree->cdr->cdr) {
  ------------------
  |  Branch (3078:13): [True: 0, False: 0]
  |  Branch (3078:21): [True: 0, False: 0]
  |  Branch (3078:34): [True: 0, False: 0]
  ------------------
 3079|      0|          codegen(s, tree->cdr->cdr, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3080|      0|        }
 3081|      0|        else {
 3082|      0|          gen_blkmove(s, 0, lv);
 3083|      0|        }
 3084|      0|        n = 0;
 3085|      0|      }
 3086|      0|      s->sp = sp;
 3087|      0|      genop_2(s, OP_SUPER, cursp(), n);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3088|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3088:11): [True: 0, False: 0]
  ------------------
 3089|      0|    }
 3090|      0|    break;
 3091|       |
 3092|      0|  case NODE_RETURN:
  ------------------
  |  Branch (3092:3): [True: 0, False: 1.89M]
  ------------------
 3093|      0|    if (tree) {
  ------------------
  |  Branch (3093:9): [True: 0, False: 0]
  ------------------
 3094|      0|      gen_retval(s, tree);
 3095|      0|    }
 3096|      0|    else {
 3097|      0|      genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3098|      0|    }
 3099|      0|    if (s->loop) {
  ------------------
  |  Branch (3099:9): [True: 0, False: 0]
  ------------------
 3100|      0|      gen_return(s, OP_RETURN_BLK, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3101|      0|    }
 3102|      0|    else {
 3103|      0|      gen_return(s, OP_RETURN, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3104|      0|    }
 3105|      0|    if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3105:9): [True: 0, False: 0]
  ------------------
 3106|      0|    break;
 3107|       |
 3108|      0|  case NODE_YIELD:
  ------------------
  |  Branch (3108:3): [True: 0, False: 1.89M]
  ------------------
 3109|      0|    {
 3110|      0|      codegen_scope *s2 = s;
 3111|      0|      int lv = 0, ainfo = -1;
 3112|      0|      int n = 0, sendv = 0;
 3113|       |
 3114|      0|      while (!s2->mscope) {
  ------------------
  |  Branch (3114:14): [True: 0, False: 0]
  ------------------
 3115|      0|        lv++;
 3116|      0|        s2 = s2->prev;
 3117|      0|        if (!s2) break;
  ------------------
  |  Branch (3117:13): [True: 0, False: 0]
  ------------------
 3118|      0|      }
 3119|      0|      if (s2) {
  ------------------
  |  Branch (3119:11): [True: 0, False: 0]
  ------------------
 3120|      0|        ainfo = (int)s2->ainfo;
 3121|      0|      }
 3122|      0|      if (ainfo < 0) codegen_error(s, "invalid yield (SyntaxError)");
  ------------------
  |  Branch (3122:11): [True: 0, False: 0]
  ------------------
 3123|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3124|      0|      if (tree) {
  ------------------
  |  Branch (3124:11): [True: 0, False: 0]
  ------------------
 3125|      0|        n = gen_values(s, tree, VAL, 14);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3126|      0|        if (n < 0) {
  ------------------
  |  Branch (3126:13): [True: 0, False: 0]
  ------------------
 3127|      0|          n = sendv = 1;
 3128|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3129|      0|        }
 3130|      0|      }
 3131|      0|      push();pop(); /* space for a block */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                    push();pop(); /* space for a block */
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3132|      0|      pop_n(n+1);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3133|      0|      genop_2S(s, OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf));
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3134|      0|      if (sendv) n = CALL_MAXARGS;
  ------------------
  |  | 1568|      0|#define CALL_MAXARGS 15
  ------------------
  |  Branch (3134:11): [True: 0, False: 0]
  ------------------
 3135|      0|      genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, call)), n);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                    genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM_2(s->mrb, call)), n);
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 3136|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3136:11): [True: 0, False: 0]
  ------------------
 3137|      0|    }
 3138|      0|    break;
 3139|       |
 3140|      0|  case NODE_BREAK:
  ------------------
  |  Branch (3140:3): [True: 0, False: 1.89M]
  ------------------
 3141|      0|    loop_break(s, tree);
 3142|      0|    if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3142:9): [True: 0, False: 0]
  ------------------
 3143|      0|    break;
 3144|       |
 3145|      0|  case NODE_NEXT:
  ------------------
  |  Branch (3145:3): [True: 0, False: 1.89M]
  ------------------
 3146|      0|    if (!s->loop) {
  ------------------
  |  Branch (3146:9): [True: 0, False: 0]
  ------------------
 3147|      0|      raise_error(s, "unexpected next");
 3148|      0|    }
 3149|      0|    else if (s->loop->type == LOOP_NORMAL) {
  ------------------
  |  Branch (3149:14): [True: 0, False: 0]
  ------------------
 3150|      0|      codegen(s, tree, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 3151|      0|      genjmp(s, OP_JMPUW, s->loop->pc0);
 3152|      0|    }
 3153|      0|    else {
 3154|      0|      if (tree) {
  ------------------
  |  Branch (3154:11): [True: 0, False: 0]
  ------------------
 3155|      0|        codegen(s, tree, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3156|      0|        pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3157|      0|      }
 3158|      0|      else {
 3159|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3160|      0|      }
 3161|      0|      gen_return(s, OP_RETURN, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3162|      0|    }
 3163|      0|    if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3163:9): [True: 0, False: 0]
  ------------------
 3164|      0|    break;
 3165|       |
 3166|      0|  case NODE_REDO:
  ------------------
  |  Branch (3166:3): [True: 0, False: 1.89M]
  ------------------
 3167|      0|    if (!s->loop || s->loop->type == LOOP_BEGIN || s->loop->type == LOOP_RESCUE) {
  ------------------
  |  Branch (3167:9): [True: 0, False: 0]
  |  Branch (3167:21): [True: 0, False: 0]
  |  Branch (3167:52): [True: 0, False: 0]
  ------------------
 3168|      0|      raise_error(s, "unexpected redo");
 3169|      0|    }
 3170|      0|    else {
 3171|      0|      genjmp(s, OP_JMPUW, s->loop->pc1);
 3172|      0|    }
 3173|      0|    if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3173:9): [True: 0, False: 0]
  ------------------
 3174|      0|    break;
 3175|       |
 3176|      0|  case NODE_RETRY:
  ------------------
  |  Branch (3176:3): [True: 0, False: 1.89M]
  ------------------
 3177|      0|    {
 3178|      0|      const char *msg = "unexpected retry";
 3179|      0|      const struct loopinfo *lp = s->loop;
 3180|       |
 3181|      0|      while (lp && lp->type != LOOP_RESCUE) {
  ------------------
  |  Branch (3181:14): [True: 0, False: 0]
  |  Branch (3181:20): [True: 0, False: 0]
  ------------------
 3182|      0|        lp = lp->prev;
 3183|      0|      }
 3184|      0|      if (!lp) {
  ------------------
  |  Branch (3184:11): [True: 0, False: 0]
  ------------------
 3185|      0|        raise_error(s, msg);
 3186|      0|      }
 3187|      0|      else {
 3188|      0|        genjmp(s, OP_JMPUW, lp->pc0);
 3189|      0|      }
 3190|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3190:11): [True: 0, False: 0]
  ------------------
 3191|      0|    }
 3192|      0|    break;
 3193|       |
 3194|  72.1k|  case NODE_LVAR:
  ------------------
  |  Branch (3194:3): [True: 72.1k, False: 1.82M]
  ------------------
 3195|  72.1k|    if (val) {
  ------------------
  |  Branch (3195:9): [True: 70.8k, False: 1.30k]
  ------------------
 3196|  70.8k|      int idx = lv_idx(s, nsym(tree));
  ------------------
  |  | 1229|  70.8k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3197|       |
 3198|  70.8k|      if (idx > 0) {
  ------------------
  |  Branch (3198:11): [True: 70.8k, False: 0]
  ------------------
 3199|  70.8k|        gen_move(s, cursp(), idx, val);
  ------------------
  |  |  990|  70.8k|#define cursp() (s->sp)
  ------------------
 3200|  70.8k|      }
 3201|      0|      else {
 3202|      0|        gen_getupvar(s, cursp(), nsym(tree));
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                      gen_getupvar(s, cursp(), nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3203|      0|      }
 3204|  70.8k|      push();
  ------------------
  |  |  986|  70.8k|#define push() push_n_(s,1)
  ------------------
 3205|  70.8k|    }
 3206|  72.1k|    break;
 3207|       |
 3208|      0|  case NODE_NVAR:
  ------------------
  |  Branch (3208:3): [True: 0, False: 1.89M]
  ------------------
 3209|      0|    if (val) {
  ------------------
  |  Branch (3209:9): [True: 0, False: 0]
  ------------------
 3210|      0|      int idx = nint(tree);
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3211|       |
 3212|      0|      gen_move(s, cursp(), idx, val);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3213|       |
 3214|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3215|      0|    }
 3216|      0|    break;
 3217|       |
 3218|      0|  case NODE_GVAR:
  ------------------
  |  Branch (3218:3): [True: 0, False: 1.89M]
  ------------------
 3219|      0|    {
 3220|      0|      int sym = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3221|       |
 3222|      0|      genop_2(s, OP_GETGV, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3223|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3223:11): [True: 0, False: 0]
  ------------------
 3224|      0|    }
 3225|      0|    break;
 3226|       |
 3227|  30.8k|  case NODE_IVAR:
  ------------------
  |  Branch (3227:3): [True: 30.8k, False: 1.86M]
  ------------------
 3228|  30.8k|    {
 3229|  30.8k|      int sym = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|  30.8k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3230|       |
 3231|  30.8k|      genop_2(s, OP_GETIV, cursp(), sym);
  ------------------
  |  |  990|  30.8k|#define cursp() (s->sp)
  ------------------
 3232|  30.8k|      if (val) push();
  ------------------
  |  |  986|  30.8k|#define push() push_n_(s,1)
  ------------------
  |  Branch (3232:11): [True: 30.8k, False: 0]
  ------------------
 3233|  30.8k|    }
 3234|  30.8k|    break;
 3235|       |
 3236|      0|  case NODE_CVAR:
  ------------------
  |  Branch (3236:3): [True: 0, False: 1.89M]
  ------------------
 3237|      0|    {
 3238|      0|      int sym = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3239|       |
 3240|      0|      genop_2(s, OP_GETCV, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3241|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3241:11): [True: 0, False: 0]
  ------------------
 3242|      0|    }
 3243|      0|    break;
 3244|       |
 3245|  42.8k|  case NODE_CONST:
  ------------------
  |  Branch (3245:3): [True: 42.8k, False: 1.85M]
  ------------------
 3246|  42.8k|    {
 3247|  42.8k|      int sym = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|  42.8k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3248|       |
 3249|  42.8k|      genop_2(s, OP_GETCONST, cursp(), sym);
  ------------------
  |  |  990|  42.8k|#define cursp() (s->sp)
  ------------------
 3250|  42.8k|      if (val) push();
  ------------------
  |  |  986|  42.8k|#define push() push_n_(s,1)
  ------------------
  |  Branch (3250:11): [True: 42.8k, False: 0]
  ------------------
 3251|  42.8k|    }
 3252|  42.8k|    break;
 3253|       |
 3254|      0|  case NODE_BACK_REF:
  ------------------
  |  Branch (3254:3): [True: 0, False: 1.89M]
  ------------------
 3255|      0|    if (val) {
  ------------------
  |  Branch (3255:9): [True: 0, False: 0]
  ------------------
 3256|      0|      char buf[] = {'$', nchar(tree)};
  ------------------
  |  | 1228|      0|#define nchar(x) ((char)(intptr_t)(x))
  ------------------
 3257|      0|      int sym = new_sym(s, mrb_intern(s->mrb, buf, sizeof(buf)));
 3258|       |
 3259|      0|      genop_2(s, OP_GETGV, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3260|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3261|      0|    }
 3262|      0|    break;
 3263|       |
 3264|      0|  case NODE_NTH_REF:
  ------------------
  |  Branch (3264:3): [True: 0, False: 1.89M]
  ------------------
 3265|      0|    if (val) {
  ------------------
  |  Branch (3265:9): [True: 0, False: 0]
  ------------------
 3266|      0|      mrb_state *mrb = s->mrb;
 3267|      0|      mrb_value str;
 3268|      0|      int sym;
 3269|       |
 3270|      0|      str = mrb_format(mrb, "$%d", nint(tree));
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3271|      0|      sym = new_sym(s, mrb_intern_str(mrb, str));
 3272|      0|      genop_2(s, OP_GETGV, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3273|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3274|      0|    }
 3275|      0|    break;
 3276|       |
 3277|      0|  case NODE_ARG:
  ------------------
  |  Branch (3277:3): [True: 0, False: 1.89M]
  ------------------
 3278|       |    /* should not happen */
 3279|      0|    break;
 3280|       |
 3281|      0|  case NODE_BLOCK_ARG:
  ------------------
  |  Branch (3281:3): [True: 0, False: 1.89M]
  ------------------
 3282|      0|    if (!tree) {
  ------------------
  |  Branch (3282:9): [True: 0, False: 0]
  ------------------
 3283|      0|      int idx = lv_idx(s, MRB_OPSYM_2(s->mrb, and));
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
 3284|       |
 3285|      0|      if (idx == 0) {
  ------------------
  |  Branch (3285:11): [True: 0, False: 0]
  ------------------
 3286|      0|        gen_getupvar(s, cursp(), MRB_OPSYM_2(s->mrb, and));
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
                      gen_getupvar(s, cursp(), MRB_OPSYM_2(s->mrb, and));
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
 3287|      0|      }
 3288|      0|      else {
 3289|      0|        gen_move(s, cursp(), idx, val);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3290|      0|      }
 3291|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3291:11): [True: 0, False: 0]
  ------------------
 3292|      0|    }
 3293|      0|    else {
 3294|      0|      codegen(s, tree, val);
 3295|      0|    }
 3296|      0|    break;
 3297|       |
 3298|   685k|  case NODE_INT:
  ------------------
  |  Branch (3298:3): [True: 685k, False: 1.21M]
  ------------------
 3299|   685k|    if (val) {
  ------------------
  |  Branch (3299:9): [True: 656k, False: 28.8k]
  ------------------
 3300|   656k|      char *p = (char*)tree->car;
 3301|   656k|      int base = nint(tree->cdr->car);
  ------------------
  |  | 1227|   656k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3302|   656k|      mrb_int i;
 3303|   656k|      mrb_bool overflow;
 3304|       |
 3305|   656k|      i = readint(s, p, base, FALSE, &overflow);
  ------------------
  |  |   51|   656k|#  define FALSE 0
  ------------------
 3306|   656k|      if (overflow) {
  ------------------
  |  Branch (3306:11): [True: 0, False: 656k]
  ------------------
 3307|      0|        int off = new_litbint(s, p, base, FALSE);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 3308|      0|        genop_2(s, OP_LOADL, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3309|      0|      }
 3310|   656k|      else {
 3311|   656k|        gen_int(s, cursp(), i);
  ------------------
  |  |  990|   656k|#define cursp() (s->sp)
  ------------------
 3312|   656k|      }
 3313|   656k|      push();
  ------------------
  |  |  986|   656k|#define push() push_n_(s,1)
  ------------------
 3314|   656k|    }
 3315|   685k|    break;
 3316|       |
 3317|      0|#ifndef MRB_NO_FLOAT
 3318|      0|  case NODE_FLOAT:
  ------------------
  |  Branch (3318:3): [True: 0, False: 1.89M]
  ------------------
 3319|      0|    if (val) {
  ------------------
  |  Branch (3319:9): [True: 0, False: 0]
  ------------------
 3320|      0|      char *p = (char*)tree;
 3321|      0|      double f;
 3322|      0|      mrb_read_float(p, NULL, &f);
 3323|      0|      int off = new_lit_float(s, (mrb_float)f);
 3324|       |
 3325|      0|      genop_2(s, OP_LOADL, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3326|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3327|      0|    }
 3328|      0|    break;
 3329|      0|#endif
 3330|       |
 3331|      0|  case NODE_NEGATE:
  ------------------
  |  Branch (3331:3): [True: 0, False: 1.89M]
  ------------------
 3332|      0|    {
 3333|      0|      nt = nint(tree->car);
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3334|      0|      switch (nt) {
 3335|      0|#ifndef MRB_NO_FLOAT
 3336|      0|      case NODE_FLOAT:
  ------------------
  |  Branch (3336:7): [True: 0, False: 0]
  ------------------
 3337|      0|        if (val) {
  ------------------
  |  Branch (3337:13): [True: 0, False: 0]
  ------------------
 3338|      0|          char *p = (char*)tree->cdr;
 3339|      0|          double f;
 3340|      0|          mrb_read_float(p, NULL, &f);
 3341|      0|          int off = new_lit_float(s, (mrb_float)-f);
 3342|       |
 3343|      0|          genop_2(s, OP_LOADL, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3344|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3345|      0|        }
 3346|      0|        break;
 3347|      0|#endif
 3348|       |
 3349|      0|      case NODE_INT:
  ------------------
  |  Branch (3349:7): [True: 0, False: 0]
  ------------------
 3350|      0|        if (val) {
  ------------------
  |  Branch (3350:13): [True: 0, False: 0]
  ------------------
 3351|      0|          char *p = (char*)tree->cdr->car;
 3352|      0|          int base = nint(tree->cdr->cdr->car);
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3353|      0|          mrb_int i;
 3354|      0|          mrb_bool overflow;
 3355|       |
 3356|      0|          i = readint(s, p, base, TRUE, &overflow);
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 3357|      0|          if (overflow) {
  ------------------
  |  Branch (3357:15): [True: 0, False: 0]
  ------------------
 3358|      0|            int off = new_litbint(s, p, base, TRUE);
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 3359|      0|            genop_2(s, OP_LOADL, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3360|      0|          }
 3361|      0|          else {
 3362|      0|            gen_int(s, cursp(), i);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3363|      0|          }
 3364|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3365|      0|        }
 3366|      0|        break;
 3367|       |
 3368|      0|      default:
  ------------------
  |  Branch (3368:7): [True: 0, False: 0]
  ------------------
 3369|      0|        if (val) {
  ------------------
  |  Branch (3369:13): [True: 0, False: 0]
  ------------------
 3370|      0|          codegen(s, tree, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3371|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3372|      0|          push_n(2);pop_n(2); /* space for receiver&block */
  ------------------
  |  |  987|      0|#define push_n(n) push_n_(s,n)
  ------------------
                        push_n(2);pop_n(2); /* space for receiver&block */
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3373|      0|          mrb_sym minus = MRB_OPSYM_2(s->mrb, minus);
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
 3374|      0|          if (!gen_uniop(s, minus, cursp())) {
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
  |  Branch (3374:15): [True: 0, False: 0]
  ------------------
 3375|      0|            genop_3(s, OP_SEND, cursp(), new_sym(s, minus), 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3376|      0|          }
 3377|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3378|      0|        }
 3379|      0|        else {
 3380|      0|          codegen(s, tree, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 3381|      0|        }
 3382|      0|        break;
 3383|      0|      }
 3384|      0|    }
 3385|      0|    break;
 3386|       |
 3387|   258k|  case NODE_STR:
  ------------------
  |  Branch (3387:3): [True: 258k, False: 1.64M]
  ------------------
 3388|   258k|    if (val) {
  ------------------
  |  Branch (3388:9): [True: 258k, False: 0]
  ------------------
 3389|   258k|      char *p = (char*)tree->car;
 3390|   258k|      mrb_int len = nint(tree->cdr);
  ------------------
  |  | 1227|   258k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3391|   258k|      int off = new_lit_str(s, p, len);
 3392|       |
 3393|   258k|      genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|   258k|#define cursp() (s->sp)
  ------------------
 3394|   258k|      push();
  ------------------
  |  |  986|   258k|#define push() push_n_(s,1)
  ------------------
 3395|   258k|    }
 3396|   258k|    break;
 3397|       |
 3398|      0|  case NODE_HEREDOC:
  ------------------
  |  Branch (3398:3): [True: 0, False: 1.89M]
  ------------------
 3399|      0|    tree = ((struct mrb_parser_heredoc_info*)tree)->doc;
 3400|       |    /* fall through */
 3401|      0|  case NODE_DSTR:
  ------------------
  |  Branch (3401:3): [True: 0, False: 1.89M]
  ------------------
 3402|      0|    if (val) {
  ------------------
  |  Branch (3402:9): [True: 0, False: 0]
  ------------------
 3403|      0|      node *n = tree;
 3404|       |
 3405|      0|      if (!n) {
  ------------------
  |  Branch (3405:11): [True: 0, False: 0]
  ------------------
 3406|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3407|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3408|      0|        break;
 3409|      0|      }
 3410|      0|      codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3411|      0|      n = n->cdr;
 3412|      0|      while (n) {
  ------------------
  |  Branch (3412:14): [True: 0, False: 0]
  ------------------
 3413|      0|        codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3414|      0|        pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3415|      0|        genop_1(s, OP_STRCAT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3416|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3417|      0|        n = n->cdr;
 3418|      0|      }
 3419|      0|    }
 3420|      0|    else {
 3421|      0|      node *n = tree;
 3422|       |
 3423|      0|      while (n) {
  ------------------
  |  Branch (3423:14): [True: 0, False: 0]
  ------------------
 3424|      0|        if (nint(n->car->car) != NODE_STR) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (3424:13): [True: 0, False: 0]
  ------------------
 3425|      0|          codegen(s, n->car, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 3426|      0|        }
 3427|      0|        n = n->cdr;
 3428|      0|      }
 3429|      0|    }
 3430|      0|    break;
 3431|       |
 3432|      0|  case NODE_WORDS:
  ------------------
  |  Branch (3432:3): [True: 0, False: 1.89M]
  ------------------
 3433|      0|    gen_literal_array(s, tree, FALSE, val);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 3434|      0|    break;
 3435|       |
 3436|      0|  case NODE_SYMBOLS:
  ------------------
  |  Branch (3436:3): [True: 0, False: 1.89M]
  ------------------
 3437|      0|    gen_literal_array(s, tree, TRUE, val);
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 3438|      0|    break;
 3439|       |
 3440|      0|  case NODE_DXSTR:
  ------------------
  |  Branch (3440:3): [True: 0, False: 1.89M]
  ------------------
 3441|      0|    {
 3442|      0|      node *n;
 3443|      0|      int sym = new_sym(s, MRB_SYM_2(s->mrb, Kernel));
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 3444|       |
 3445|      0|      genop_1(s, OP_LOADSELF, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3446|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3447|      0|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3448|      0|      n = tree->cdr;
 3449|      0|      while (n) {
  ------------------
  |  Branch (3449:14): [True: 0, False: 0]
  ------------------
 3450|      0|        if (nint(n->car->car) == NODE_XSTR) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (3450:13): [True: 0, False: 0]
  ------------------
 3451|      0|          n->car->car = (struct mrb_ast_node*)(intptr_t)NODE_STR;
 3452|      0|          mrb_assert(!n->cdr); /* must be the end */
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 3453|      0|        }
 3454|      0|        codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3455|      0|        pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3456|      0|        genop_1(s, OP_STRCAT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3457|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3458|      0|        n = n->cdr;
 3459|      0|      }
 3460|      0|      push();                   /* for block */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3461|      0|      pop_n(3);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3462|      0|      sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
 3463|      0|      genop_3(s, OP_SEND, cursp(), sym, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3464|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3464:11): [True: 0, False: 0]
  ------------------
 3465|      0|    }
 3466|      0|    break;
 3467|       |
 3468|      0|  case NODE_XSTR:
  ------------------
  |  Branch (3468:3): [True: 0, False: 1.89M]
  ------------------
 3469|      0|    {
 3470|      0|      char *p = (char*)tree->car;
 3471|      0|      mrb_int len = nint(tree->cdr);
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 3472|      0|      int off = new_lit_str(s, p, len);
 3473|      0|      int sym;
 3474|       |
 3475|      0|      genop_1(s, OP_LOADSELF, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3476|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3477|      0|      genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3478|      0|      push(); push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                    push(); push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3479|      0|      pop_n(3);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3480|      0|      sym = new_sym(s, MRB_OPSYM_2(s->mrb, tick)); /* ` */
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
 3481|      0|      genop_3(s, OP_SEND, cursp(), sym, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3482|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3482:11): [True: 0, False: 0]
  ------------------
 3483|      0|    }
 3484|      0|    break;
 3485|       |
 3486|      0|  case NODE_REGX:
  ------------------
  |  Branch (3486:3): [True: 0, False: 1.89M]
  ------------------
 3487|      0|    if (val) {
  ------------------
  |  Branch (3487:9): [True: 0, False: 0]
  ------------------
 3488|      0|      char *p1 = (char*)tree->car;
 3489|      0|      char *p2 = (char*)tree->cdr->car;
 3490|      0|      char *p3 = (char*)tree->cdr->cdr;
 3491|      0|      int sym = new_sym(s, mrb_intern_lit(s->mrb, REGEXP_CLASS));
  ------------------
  |  | 1164|      0|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
 3492|      0|      int off = new_lit_cstr(s, p1);
 3493|      0|      int argc = 1;
 3494|       |
 3495|      0|      genop_1(s, OP_OCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3496|      0|      genop_2(s, OP_GETMCNST, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3497|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3498|      0|      genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3499|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3500|      0|      if (p2 || p3) {
  ------------------
  |  Branch (3500:11): [True: 0, False: 0]
  |  Branch (3500:17): [True: 0, False: 0]
  ------------------
 3501|      0|        if (p2) { /* opt */
  ------------------
  |  Branch (3501:13): [True: 0, False: 0]
  ------------------
 3502|      0|          off = new_lit_cstr(s, p2);
 3503|      0|          genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3504|      0|        }
 3505|      0|        else {
 3506|      0|          genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3507|      0|        }
 3508|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3509|      0|        argc++;
 3510|      0|        if (p3) { /* enc */
  ------------------
  |  Branch (3510:13): [True: 0, False: 0]
  ------------------
 3511|      0|          off = new_lit_str(s, p3, 1);
 3512|      0|          genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3513|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3514|      0|          argc++;
 3515|      0|        }
 3516|      0|      }
 3517|      0|      push(); /* space for a block */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3518|      0|      pop_n(argc+2);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3519|      0|      sym = new_sym(s, MRB_SYM_2(s->mrb, compile));
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 3520|      0|      genop_3(s, OP_SEND, cursp(), sym, argc);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3521|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3522|      0|    }
 3523|      0|    break;
 3524|       |
 3525|      0|  case NODE_DREGX:
  ------------------
  |  Branch (3525:3): [True: 0, False: 1.89M]
  ------------------
 3526|      0|    if (val) {
  ------------------
  |  Branch (3526:9): [True: 0, False: 0]
  ------------------
 3527|      0|      node *n = tree->car;
 3528|      0|      int sym = new_sym(s, mrb_intern_lit(s->mrb, REGEXP_CLASS));
  ------------------
  |  | 1164|      0|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
 3529|      0|      int argc = 1;
 3530|      0|      int off;
 3531|      0|      char *p;
 3532|       |
 3533|      0|      genop_1(s, OP_OCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3534|      0|      genop_2(s, OP_GETMCNST, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3535|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3536|      0|      codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3537|      0|      n = n->cdr;
 3538|      0|      while (n) {
  ------------------
  |  Branch (3538:14): [True: 0, False: 0]
  ------------------
 3539|      0|        codegen(s, n->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3540|      0|        pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3541|      0|        genop_1(s, OP_STRCAT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3542|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3543|      0|        n = n->cdr;
 3544|      0|      }
 3545|      0|      n = tree->cdr->cdr;
 3546|      0|      if (n->car) { /* tail */
  ------------------
  |  Branch (3546:11): [True: 0, False: 0]
  ------------------
 3547|      0|        p = (char*)n->car;
 3548|      0|        off = new_lit_cstr(s, p);
 3549|      0|        codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3550|      0|        genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3551|      0|        pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3552|      0|        genop_1(s, OP_STRCAT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3553|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3554|      0|      }
 3555|      0|      if (n->cdr->car) { /* opt */
  ------------------
  |  Branch (3555:11): [True: 0, False: 0]
  ------------------
 3556|      0|        char *p2 = (char*)n->cdr->car;
 3557|      0|        off = new_lit_cstr(s, p2);
 3558|      0|        genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3559|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3560|      0|        argc++;
 3561|      0|      }
 3562|      0|      if (n->cdr->cdr) { /* enc */
  ------------------
  |  Branch (3562:11): [True: 0, False: 0]
  ------------------
 3563|      0|        char *p2 = (char*)n->cdr->cdr;
 3564|      0|        off = new_lit_cstr(s, p2);
 3565|      0|        genop_2(s, OP_STRING, cursp(), off);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3566|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3567|      0|        argc++;
 3568|      0|      }
 3569|      0|      push(); /* space for a block */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3570|      0|      pop_n(argc+2);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 3571|      0|      sym = new_sym(s, MRB_SYM_2(s->mrb, compile));
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 3572|      0|      genop_3(s, OP_SEND, cursp(), sym, argc);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3573|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3574|      0|    }
 3575|      0|    else {
 3576|      0|      node *n = tree->car;
 3577|       |
 3578|      0|      while (n) {
  ------------------
  |  Branch (3578:14): [True: 0, False: 0]
  ------------------
 3579|      0|        if (nint(n->car->car) != NODE_STR) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (3579:13): [True: 0, False: 0]
  ------------------
 3580|      0|          codegen(s, n->car, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 3581|      0|        }
 3582|      0|        n = n->cdr;
 3583|      0|      }
 3584|      0|    }
 3585|      0|    break;
 3586|       |
 3587|      0|  case NODE_SYM:
  ------------------
  |  Branch (3587:3): [True: 0, False: 1.89M]
  ------------------
 3588|      0|    if (val) {
  ------------------
  |  Branch (3588:9): [True: 0, False: 0]
  ------------------
 3589|      0|      int sym = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3590|       |
 3591|      0|      genop_2(s, OP_LOADSYM, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3592|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3593|      0|    }
 3594|      0|    break;
 3595|       |
 3596|      0|  case NODE_DSYM:
  ------------------
  |  Branch (3596:3): [True: 0, False: 1.89M]
  ------------------
 3597|      0|    codegen(s, tree, val);
 3598|      0|    if (val) {
  ------------------
  |  Branch (3598:9): [True: 0, False: 0]
  ------------------
 3599|      0|      gen_intern(s);
 3600|      0|    }
 3601|      0|    break;
 3602|       |
 3603|      0|  case NODE_SELF:
  ------------------
  |  Branch (3603:3): [True: 0, False: 1.89M]
  ------------------
 3604|      0|    if (val) {
  ------------------
  |  Branch (3604:9): [True: 0, False: 0]
  ------------------
 3605|      0|      genop_1(s, OP_LOADSELF, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3606|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3607|      0|    }
 3608|      0|    break;
 3609|       |
 3610|      0|  case NODE_NIL:
  ------------------
  |  Branch (3610:3): [True: 0, False: 1.89M]
  ------------------
 3611|      0|    if (val) {
  ------------------
  |  Branch (3611:9): [True: 0, False: 0]
  ------------------
 3612|      0|      genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3613|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3614|      0|    }
 3615|      0|    break;
 3616|       |
 3617|      0|  case NODE_TRUE:
  ------------------
  |  Branch (3617:3): [True: 0, False: 1.89M]
  ------------------
 3618|      0|    if (val) {
  ------------------
  |  Branch (3618:9): [True: 0, False: 0]
  ------------------
 3619|      0|      genop_1(s, OP_LOADT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3620|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3621|      0|    }
 3622|      0|    break;
 3623|       |
 3624|      0|  case NODE_FALSE:
  ------------------
  |  Branch (3624:3): [True: 0, False: 1.89M]
  ------------------
 3625|      0|    if (val) {
  ------------------
  |  Branch (3625:9): [True: 0, False: 0]
  ------------------
 3626|      0|      genop_1(s, OP_LOADF, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3627|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3628|      0|    }
 3629|      0|    break;
 3630|       |
 3631|      0|  case NODE_ALIAS:
  ------------------
  |  Branch (3631:3): [True: 0, False: 1.89M]
  ------------------
 3632|      0|    {
 3633|      0|      int a = new_sym(s, nsym(tree->car));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3634|      0|      int b = new_sym(s, nsym(tree->cdr));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3635|       |
 3636|      0|      genop_2(s, OP_ALIAS, a, b);
 3637|      0|      if (val) {
  ------------------
  |  Branch (3637:11): [True: 0, False: 0]
  ------------------
 3638|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3639|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3640|      0|      }
 3641|      0|    }
 3642|      0|   break;
 3643|       |
 3644|      0|  case NODE_UNDEF:
  ------------------
  |  Branch (3644:3): [True: 0, False: 1.89M]
  ------------------
 3645|      0|    {
 3646|      0|      node *t = tree;
 3647|       |
 3648|      0|      while (t) {
  ------------------
  |  Branch (3648:14): [True: 0, False: 0]
  ------------------
 3649|      0|        int symbol = new_sym(s, nsym(t->car));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3650|      0|        genop_1(s, OP_UNDEF, symbol);
 3651|      0|        t = t->cdr;
 3652|      0|      }
 3653|      0|      if (val) {
  ------------------
  |  Branch (3653:11): [True: 0, False: 0]
  ------------------
 3654|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3655|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3656|      0|      }
 3657|      0|    }
 3658|      0|    break;
 3659|       |
 3660|      0|  case NODE_CLASS:
  ------------------
  |  Branch (3660:3): [True: 0, False: 1.89M]
  ------------------
 3661|      0|    {
 3662|      0|      int idx;
 3663|      0|      node *body;
 3664|       |
 3665|      0|      if (tree->car->car == (node*)0) {
  ------------------
  |  Branch (3665:11): [True: 0, False: 0]
  ------------------
 3666|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3667|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3668|      0|      }
 3669|      0|      else if (tree->car->car == (node*)1) {
  ------------------
  |  Branch (3669:16): [True: 0, False: 0]
  ------------------
 3670|      0|        genop_1(s, OP_OCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3671|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3672|      0|      }
 3673|      0|      else {
 3674|      0|        codegen(s, tree->car->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3675|      0|      }
 3676|      0|      if (tree->cdr->car) {
  ------------------
  |  Branch (3676:11): [True: 0, False: 0]
  ------------------
 3677|      0|        codegen(s, tree->cdr->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3678|      0|      }
 3679|      0|      else {
 3680|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3681|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3682|      0|      }
 3683|      0|      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                    pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3684|      0|      idx = new_sym(s, nsym(tree->car->cdr));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3685|      0|      genop_2(s, OP_CLASS, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3686|      0|      body = tree->cdr->cdr->car;
 3687|      0|      if (nint(body->cdr->car) == NODE_BEGIN && body->cdr->cdr == NULL) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (3687:11): [True: 0, False: 0]
  |  Branch (3687:49): [True: 0, False: 0]
  ------------------
 3688|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3689|      0|      }
 3690|      0|      else {
 3691|      0|        idx = scope_body(s, body, val);
 3692|      0|        genop_2(s, OP_EXEC, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3693|      0|      }
 3694|      0|      if (val) {
  ------------------
  |  Branch (3694:11): [True: 0, False: 0]
  ------------------
 3695|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3696|      0|      }
 3697|      0|    }
 3698|      0|    break;
 3699|       |
 3700|      0|  case NODE_MODULE:
  ------------------
  |  Branch (3700:3): [True: 0, False: 1.89M]
  ------------------
 3701|      0|    {
 3702|      0|      int idx;
 3703|       |
 3704|      0|      if (tree->car->car == (node*)0) {
  ------------------
  |  Branch (3704:11): [True: 0, False: 0]
  ------------------
 3705|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3706|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3707|      0|      }
 3708|      0|      else if (tree->car->car == (node*)1) {
  ------------------
  |  Branch (3708:16): [True: 0, False: 0]
  ------------------
 3709|      0|        genop_1(s, OP_OCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3710|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3711|      0|      }
 3712|      0|      else {
 3713|      0|        codegen(s, tree->car->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3714|      0|      }
 3715|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3716|      0|      idx = new_sym(s, nsym(tree->car->cdr));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3717|      0|      genop_2(s, OP_MODULE, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3718|      0|      if (nint(tree->cdr->car->cdr->car) == NODE_BEGIN &&
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (3718:11): [True: 0, False: 0]
  ------------------
 3719|      0|          tree->cdr->car->cdr->cdr == NULL) {
  ------------------
  |  Branch (3719:11): [True: 0, False: 0]
  ------------------
 3720|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3721|      0|      }
 3722|      0|      else {
 3723|      0|        idx = scope_body(s, tree->cdr->car, val);
 3724|      0|        genop_2(s, OP_EXEC, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3725|      0|      }
 3726|      0|      if (val) {
  ------------------
  |  Branch (3726:11): [True: 0, False: 0]
  ------------------
 3727|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3728|      0|      }
 3729|      0|    }
 3730|      0|    break;
 3731|       |
 3732|      0|  case NODE_SCLASS:
  ------------------
  |  Branch (3732:3): [True: 0, False: 1.89M]
  ------------------
 3733|      0|    {
 3734|      0|      int idx;
 3735|       |
 3736|      0|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3737|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3738|      0|      genop_1(s, OP_SCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3739|      0|      if (nint(tree->cdr->car->cdr->car) == NODE_BEGIN &&
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (3739:11): [True: 0, False: 0]
  ------------------
 3740|      0|          tree->cdr->car->cdr->cdr == NULL) {
  ------------------
  |  Branch (3740:11): [True: 0, False: 0]
  ------------------
 3741|      0|        genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3742|      0|      }
 3743|      0|      else {
 3744|      0|        idx = scope_body(s, tree->cdr->car, val);
 3745|      0|        genop_2(s, OP_EXEC, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3746|      0|      }
 3747|      0|      if (val) {
  ------------------
  |  Branch (3747:11): [True: 0, False: 0]
  ------------------
 3748|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3749|      0|      }
 3750|      0|    }
 3751|      0|    break;
 3752|       |
 3753|  1.73k|  case NODE_DEF:
  ------------------
  |  Branch (3753:3): [True: 1.73k, False: 1.89M]
  ------------------
 3754|  1.73k|    {
 3755|  1.73k|      int sym = new_sym(s, nsym(tree->car));
  ------------------
  |  | 1229|  1.73k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3756|  1.73k|      int idx = lambda_body(s, tree->cdr, 0);
 3757|       |
 3758|  1.73k|      genop_1(s, OP_TCLASS, cursp());
  ------------------
  |  |  990|  1.73k|#define cursp() (s->sp)
  ------------------
 3759|  1.73k|      push();
  ------------------
  |  |  986|  1.73k|#define push() push_n_(s,1)
  ------------------
 3760|  1.73k|      genop_2(s, OP_METHOD, cursp(), idx);
  ------------------
  |  |  990|  1.73k|#define cursp() (s->sp)
  ------------------
 3761|  1.73k|      push(); pop();
  ------------------
  |  |  986|  1.73k|#define push() push_n_(s,1)
  ------------------
                    push(); pop();
  ------------------
  |  |  988|  1.73k|#define pop() pop_n_(s,1)
  ------------------
 3762|  1.73k|      pop();
  ------------------
  |  |  988|  1.73k|#define pop() pop_n_(s,1)
  ------------------
 3763|  1.73k|      genop_2(s, OP_DEF, cursp(), sym);
  ------------------
  |  |  990|  1.73k|#define cursp() (s->sp)
  ------------------
 3764|  1.73k|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3764:11): [True: 0, False: 1.73k]
  ------------------
 3765|  1.73k|    }
 3766|  1.73k|    break;
 3767|       |
 3768|      0|  case NODE_SDEF:
  ------------------
  |  Branch (3768:3): [True: 0, False: 1.89M]
  ------------------
 3769|      0|    {
 3770|      0|      node *recv = tree->car;
 3771|      0|      int sym = new_sym(s, nsym(tree->cdr->car));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 3772|      0|      int idx = lambda_body(s, tree->cdr->cdr, 0);
 3773|       |
 3774|      0|      codegen(s, recv, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 3775|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3776|      0|      genop_1(s, OP_SCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3777|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 3778|      0|      genop_2(s, OP_METHOD, cursp(), idx);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3779|      0|      push(); pop();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                    push(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3780|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 3781|      0|      genop_2(s, OP_DEF, cursp(), sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 3782|      0|      if (val) push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
  |  Branch (3782:11): [True: 0, False: 0]
  ------------------
 3783|      0|    }
 3784|      0|    break;
 3785|       |
 3786|      0|  case NODE_POSTEXE:
  ------------------
  |  Branch (3786:3): [True: 0, False: 1.89M]
  ------------------
 3787|      0|    codegen(s, tree, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 3788|      0|    break;
 3789|       |
 3790|      0|  default:
  ------------------
  |  Branch (3790:3): [True: 0, False: 1.89M]
  ------------------
 3791|      0|    break;
 3792|  1.89M|  }
 3793|  1.89M| exit:
 3794|  1.89M|  s->rlev = rlev;
 3795|  1.89M|}
codegen.c:genop_1:
  245|   917k|{
  246|   917k|  s->lastpc = s->pc;
  247|   917k|  check_no_ext_ops(s, a, 0);
  248|   917k|  if (a > 0xff) {
  ------------------
  |  Branch (248:7): [True: 374k, False: 543k]
  ------------------
  249|   374k|    gen_B(s, OP_EXT1);
  250|   374k|    gen_B(s, i);
  251|   374k|    gen_S(s, a);
  252|   374k|  }
  253|   543k|  else {
  254|   543k|    gen_B(s, i);
  255|   543k|    gen_B(s, (uint8_t)a);
  256|   543k|  }
  257|   917k|}
codegen.c:check_no_ext_ops:
  173|  1.61M|{
  174|  1.61M|  if (s->parser->no_ext_ops && (a | b) > 0xff) {
  ------------------
  |  Branch (174:7): [True: 0, False: 1.61M]
  |  Branch (174:32): [True: 0, False: 0]
  ------------------
  175|      0|    codegen_error(s, "need OP_EXTs instruction (currently OP_EXTs are prohibited)");
  176|      0|  }
  177|  1.61M|}
codegen.c:gen_B:
  224|  4.15M|{
  225|  4.15M|  emit_B(s, s->pc, i);
  226|  4.15M|  s->pc++;
  227|  4.15M|}
codegen.c:emit_B:
  187|  5.48M|{
  188|  5.48M|  if (pc >= s->icapa) {
  ------------------
  |  Branch (188:7): [True: 1.77k, False: 5.47M]
  ------------------
  189|  1.77k|    if (pc == UINT32_MAX) {
  ------------------
  |  Branch (189:9): [True: 0, False: 1.77k]
  ------------------
  190|      0|      codegen_error(s, "too big code block");
  191|      0|    }
  192|  1.77k|    if (pc >= UINT32_MAX / 2) {
  ------------------
  |  Branch (192:9): [True: 0, False: 1.77k]
  ------------------
  193|      0|      pc = UINT32_MAX;
  194|      0|    }
  195|  1.77k|    else {
  196|  1.77k|      s->icapa *= 2;
  197|  1.77k|    }
  198|  1.77k|    s->iseq = (mrb_code*)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
  199|  1.77k|    if (s->lines) {
  ------------------
  |  Branch (199:9): [True: 0, False: 1.77k]
  ------------------
  200|      0|      s->lines = (uint16_t*)codegen_realloc(s, s->lines, sizeof(uint16_t)*s->icapa);
  201|      0|    }
  202|  1.77k|  }
  203|  5.48M|  if (s->lines) {
  ------------------
  |  Branch (203:7): [True: 0, False: 5.48M]
  ------------------
  204|      0|    if (s->lineno > 0 || pc == 0)
  ------------------
  |  Branch (204:9): [True: 0, False: 0]
  |  Branch (204:26): [True: 0, False: 0]
  ------------------
  205|      0|      s->lines[pc] = s->lineno;
  206|      0|    else
  207|      0|      s->lines[pc] = s->lines[pc-1];
  208|      0|  }
  209|  5.48M|  s->iseq[pc] = i;
  210|  5.48M|}
codegen.c:gen_S:
  231|   604k|{
  232|   604k|  emit_S(s, s->pc, i);
  233|   604k|  s->pc += 2;
  234|   604k|}
codegen.c:emit_S:
  214|   664k|{
  215|   664k|  uint8_t hi = i>>8;
  216|   664k|  uint8_t lo = i&0xff;
  217|       |
  218|   664k|  emit_B(s, pc,   hi);
  219|   664k|  emit_B(s, pc+1, lo);
  220|   664k|}
codegen.c:push_n_:
  969|  1.50M|{
  970|  1.50M|  if (s->sp+n >= 0xffff) {
  ------------------
  |  Branch (970:7): [True: 0, False: 1.50M]
  ------------------
  971|      0|    codegen_error(s, "too complex expression");
  972|      0|  }
  973|  1.50M|  s->sp+=n;
  974|  1.50M|  nregs_update;
  ------------------
  |  |  966|  1.50M|#define nregs_update do {if (s->sp > s->nregs) s->nregs = s->sp;} while (0)
  |  |  ------------------
  |  |  |  Branch (966:30): [True: 292k, False: 1.21M]
  |  |  |  Branch (966:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
  975|  1.50M|}
codegen.c:new_label:
  181|  1.73k|{
  182|  1.73k|  return s->lastlabel = s->pc;
  183|  1.73k|}
codegen.c:pop_n_:
  979|   591k|{
  980|   591k|  if ((int)s->sp-n < 0) {
  ------------------
  |  Branch (980:7): [True: 0, False: 591k]
  ------------------
  981|      0|    codegen_error(s, "stack pointer underflow");
  982|      0|  }
  983|   591k|  s->sp-=n;
  984|   591k|}
codegen.c:genjmp:
  514|  14.3k|{
  515|  14.3k|  uint32_t pos;
  516|       |
  517|  14.3k|  genop_0(s, i);
  518|  14.3k|  pos = s->pc;
  519|  14.3k|  gen_jmpdst(s, pc);
  520|  14.3k|  return pos;
  521|  14.3k|}
codegen.c:genop_0:
  238|  61.8k|{
  239|  61.8k|  s->lastpc = s->pc;
  240|  61.8k|  gen_B(s, i);
  241|  61.8k|}
codegen.c:gen_jmpdst:
  498|  60.3k|{
  499|       |
  500|  60.3k|  if (pc == JMPLINK_START) {
  ------------------
  |  |  494|  60.3k|#define JMPLINK_START UINT32_MAX
  ------------------
  |  Branch (500:7): [True: 60.3k, False: 0]
  ------------------
  501|  60.3k|    pc = 0;
  502|  60.3k|  }
  503|  60.3k|  uint32_t pos2 = s->pc+2;
  504|  60.3k|  int32_t off = pc - pos2;
  505|       |
  506|  60.3k|  if (off > INT16_MAX || INT16_MIN > off) {
  ------------------
  |  Branch (506:7): [True: 0, False: 60.3k]
  |  Branch (506:26): [True: 0, False: 60.3k]
  ------------------
  507|      0|    codegen_error(s, "too big jump offset");
  508|      0|  }
  509|  60.3k|  gen_S(s, (uint16_t)off);
  510|  60.3k|}
codegen.c:dispatch:
  937|  63.9k|{
  938|  63.9k|  int32_t pos1;
  939|  63.9k|  int32_t offset;
  940|  63.9k|  int16_t newpos;
  941|       |
  942|  63.9k|  if (pos0 == JMPLINK_START) return 0;
  ------------------
  |  |  494|  63.9k|#define JMPLINK_START UINT32_MAX
  ------------------
  |  Branch (942:7): [True: 3.54k, False: 60.3k]
  ------------------
  943|       |
  944|  60.3k|  pos1 = pos0 + 2;
  945|  60.3k|  offset = s->pc - pos1;
  946|  60.3k|  if (offset > INT16_MAX) {
  ------------------
  |  Branch (946:7): [True: 4, False: 60.3k]
  ------------------
  947|      4|    codegen_error(s, "too big jmp offset");
  948|      4|  }
  949|  60.3k|  s->lastlabel = s->pc;
  950|  60.3k|  newpos = (int16_t)PEEK_S(s->iseq+pos0);
  ------------------
  |  |   27|  60.3k|#define PEEK_S(pc) ((pc)[0]<<8|(pc)[1])
  ------------------
  951|  60.3k|  emit_S(s, pos0, (uint16_t)offset);
  952|  60.3k|  if (newpos == 0) return 0;
  ------------------
  |  Branch (952:7): [True: 0, False: 60.3k]
  ------------------
  953|  60.3k|  return pos1+newpos;
  954|  60.3k|}
codegen.c:gen_move:
  590|   293k|{
  591|   293k|  if (nopeep || no_peephole(s)) goto normal;
  ------------------
  |  Branch (591:7): [True: 76.8k, False: 216k]
  |  Branch (591:17): [True: 857, False: 215k]
  ------------------
  592|   215k|  else if (dst == src) return;
  ------------------
  |  Branch (592:12): [True: 0, False: 215k]
  ------------------
  593|   215k|  else {
  594|   215k|    struct mrb_insn_data data = mrb_last_insn(s);
  595|       |
  596|   215k|    switch (data.insn) {
  597|  9.48k|    case OP_MOVE:
  ------------------
  |  Branch (597:5): [True: 9.48k, False: 206k]
  ------------------
  598|  9.48k|      if (dst == src) return;   /* remove useless MOVE */
  ------------------
  |  Branch (598:11): [True: 0, False: 9.48k]
  ------------------
  599|  9.48k|      if (data.a == src) {
  ------------------
  |  Branch (599:11): [True: 8.58k, False: 897]
  ------------------
  600|  8.58k|        if (data.b == dst)      /* skip swapping MOVE */
  ------------------
  |  Branch (600:13): [True: 0, False: 8.58k]
  ------------------
  601|      0|          return;
  602|  8.58k|        if (data.a < s->nlocals) goto normal;
  ------------------
  |  Branch (602:13): [True: 69, False: 8.51k]
  ------------------
  603|  8.51k|        rewind_pc(s);
  ------------------
  |  |  476|  8.51k|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  604|  8.51k|        s->lastpc = addr_pc(s, mrb_prev_pc(s, data.addr));
  ------------------
  |  |  475|  8.51k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  605|  8.51k|        gen_move(s, dst, data.b, FALSE);
  ------------------
  |  |   51|  8.51k|#  define FALSE 0
  ------------------
  606|  8.51k|        return;
  607|  8.58k|      }
  608|    897|      if (dst == data.a) {      /* skip overwritten move */
  ------------------
  |  Branch (608:11): [True: 0, False: 897]
  ------------------
  609|      0|        rewind_pc(s);
  ------------------
  |  |  476|      0|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  610|      0|        s->lastpc = addr_pc(s, mrb_prev_pc(s, data.addr));
  ------------------
  |  |  475|      0|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  611|      0|        gen_move(s, dst, src, FALSE);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  612|      0|        return;
  613|      0|      }
  614|    897|      goto normal;
  615|    897|    case OP_LOADNIL: case OP_LOADSELF: case OP_LOADT: case OP_LOADF:
  ------------------
  |  Branch (615:5): [True: 0, False: 215k]
  |  Branch (615:22): [True: 0, False: 215k]
  |  Branch (615:40): [True: 0, False: 215k]
  |  Branch (615:55): [True: 0, False: 215k]
  ------------------
  616|    138|    case OP_LOADI__1:
  ------------------
  |  Branch (616:5): [True: 138, False: 215k]
  ------------------
  617|   191k|    case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3:
  ------------------
  |  Branch (617:5): [True: 1.29k, False: 214k]
  |  Branch (617:22): [True: 189k, False: 26.1k]
  |  Branch (617:39): [True: 756, False: 214k]
  |  Branch (617:56): [True: 214, False: 215k]
  ------------------
  618|   193k|    case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7:
  ------------------
  |  Branch (618:5): [True: 258, False: 215k]
  |  Branch (618:22): [True: 213, False: 215k]
  |  Branch (618:39): [True: 895, False: 214k]
  |  Branch (618:56): [True: 371, False: 215k]
  ------------------
  619|   193k|      if (data.a != src || data.a < s->nlocals) goto normal;
  ------------------
  |  Branch (619:11): [True: 5.00k, False: 188k]
  |  Branch (619:28): [True: 72, False: 188k]
  ------------------
  620|   188k|      rewind_pc(s);
  ------------------
  |  |  476|   188k|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  621|   188k|      genop_1(s, data.insn, dst);
  622|   188k|      return;
  623|      0|    case OP_HASH:
  ------------------
  |  Branch (623:5): [True: 0, False: 215k]
  ------------------
  624|      0|      if (data.b != 0) goto normal;
  ------------------
  |  Branch (624:11): [True: 0, False: 0]
  ------------------
  625|       |      /* fall through */
  626|  1.91k|    case OP_LOADI: case OP_LOADINEG:
  ------------------
  |  Branch (626:5): [True: 1.71k, False: 213k]
  |  Branch (626:20): [True: 205, False: 215k]
  ------------------
  627|  2.16k|    case OP_LOADL: case OP_LOADSYM:
  ------------------
  |  Branch (627:5): [True: 248, False: 215k]
  |  Branch (627:20): [True: 0, False: 215k]
  ------------------
  628|  2.16k|    case OP_GETGV: case OP_GETSV: case OP_GETIV: case OP_GETCV:
  ------------------
  |  Branch (628:5): [True: 0, False: 215k]
  |  Branch (628:20): [True: 0, False: 215k]
  |  Branch (628:35): [True: 0, False: 215k]
  |  Branch (628:50): [True: 0, False: 215k]
  ------------------
  629|  2.16k|    case OP_GETCONST: case OP_STRING:
  ------------------
  |  Branch (629:5): [True: 0, False: 215k]
  |  Branch (629:23): [True: 0, False: 215k]
  ------------------
  630|  2.16k|    case OP_LAMBDA: case OP_BLOCK: case OP_METHOD: case OP_BLKPUSH:
  ------------------
  |  Branch (630:5): [True: 0, False: 215k]
  |  Branch (630:21): [True: 0, False: 215k]
  |  Branch (630:36): [True: 0, False: 215k]
  |  Branch (630:52): [True: 0, False: 215k]
  ------------------
  631|  2.16k|      if (data.a != src || data.a < s->nlocals) goto normal;
  ------------------
  |  Branch (631:11): [True: 165, False: 2.00k]
  |  Branch (631:28): [True: 7, False: 1.99k]
  ------------------
  632|  1.99k|      rewind_pc(s);
  ------------------
  |  |  476|  1.99k|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  633|  1.99k|      genop_2(s, data.insn, dst, data.b);
  634|  1.99k|      return;
  635|    255|    case OP_LOADI16:
  ------------------
  |  Branch (635:5): [True: 255, False: 215k]
  ------------------
  636|    255|      if (data.a != src || data.a < s->nlocals) goto normal;
  ------------------
  |  Branch (636:11): [True: 27, False: 228]
  |  Branch (636:28): [True: 36, False: 192]
  ------------------
  637|    192|      rewind_pc(s);
  ------------------
  |  |  476|    192|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  638|    192|      genop_2S(s, data.insn, dst, data.b);
  639|    192|      return;
  640|    176|    case OP_LOADI32:
  ------------------
  |  Branch (640:5): [True: 176, False: 215k]
  ------------------
  641|    176|      if (data.a != src || data.a < s->nlocals) goto normal;
  ------------------
  |  Branch (641:11): [True: 33, False: 143]
  |  Branch (641:28): [True: 16, False: 127]
  ------------------
  642|    127|      else {
  643|    127|        uint32_t i = (uint32_t)data.b<<16|data.c;
  644|    127|        rewind_pc(s);
  ------------------
  |  |  476|    127|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  645|    127|        genop_2SS(s, data.insn, dst, i);
  646|    127|      }
  647|    127|      return;
  648|    127|    case OP_ARRAY:
  ------------------
  |  Branch (648:5): [True: 0, False: 215k]
  ------------------
  649|      0|      if (data.a != src || data.a < s->nlocals || data.a < dst) goto normal;
  ------------------
  |  Branch (649:11): [True: 0, False: 0]
  |  Branch (649:28): [True: 0, False: 0]
  |  Branch (649:51): [True: 0, False: 0]
  ------------------
  650|      0|      rewind_pc(s);
  ------------------
  |  |  476|      0|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  651|      0|      if (data.b == 0 || dst == data.a)
  ------------------
  |  Branch (651:11): [True: 0, False: 0]
  |  Branch (651:26): [True: 0, False: 0]
  ------------------
  652|      0|        genop_2(s, OP_ARRAY, dst, 0);
  653|      0|      else
  654|      0|        genop_3(s, OP_ARRAY2, dst, data.a, data.b);
  655|      0|      return;
  656|      0|    case OP_ARRAY2:
  ------------------
  |  Branch (656:5): [True: 0, False: 215k]
  ------------------
  657|      0|      if (data.a != src || data.a < s->nlocals || data.a < dst) goto normal;
  ------------------
  |  Branch (657:11): [True: 0, False: 0]
  |  Branch (657:28): [True: 0, False: 0]
  |  Branch (657:51): [True: 0, False: 0]
  ------------------
  658|      0|      rewind_pc(s);
  ------------------
  |  |  476|      0|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  659|      0|      genop_3(s, OP_ARRAY2, dst, data.b, data.c);
  660|      0|      return;
  661|      0|    case OP_AREF:
  ------------------
  |  Branch (661:5): [True: 0, False: 215k]
  ------------------
  662|      0|    case OP_GETUPVAR:
  ------------------
  |  Branch (662:5): [True: 0, False: 215k]
  ------------------
  663|      0|      if (data.a != src || data.a < s->nlocals) goto normal;
  ------------------
  |  Branch (663:11): [True: 0, False: 0]
  |  Branch (663:28): [True: 0, False: 0]
  ------------------
  664|      0|      rewind_pc(s);
  ------------------
  |  |  476|      0|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  665|      0|      genop_3(s, data.insn, dst, data.b, data.c);
  666|      0|      return;
  667|  1.39k|    case OP_ADDI: case OP_SUBI:
  ------------------
  |  Branch (667:5): [True: 1.01k, False: 214k]
  |  Branch (667:19): [True: 388, False: 215k]
  ------------------
  668|  1.39k|      if (addr_pc(s, data.addr) == s->lastlabel || data.a != src || data.a < s->nlocals) goto normal;
  ------------------
  |  |  475|  1.39k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  |  Branch (668:11): [True: 322, False: 1.07k]
  |  Branch (668:52): [True: 27, False: 1.05k]
  |  Branch (668:69): [True: 0, False: 1.05k]
  ------------------
  669|  1.05k|      else {
  670|  1.05k|        struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr));
  671|  1.05k|        if (data0.insn != OP_MOVE || data0.a != data.a || data0.b != dst) goto normal;
  ------------------
  |  Branch (671:13): [True: 704, False: 346]
  |  Branch (671:38): [True: 0, False: 346]
  |  Branch (671:59): [True: 346, False: 0]
  ------------------
  672|      0|        s->pc = addr_pc(s, data0.addr);
  ------------------
  |  |  475|      0|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  673|      0|        if (addr_pc(s, data0.addr) != s->lastlabel) {
  ------------------
  |  |  475|      0|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  |  Branch (673:13): [True: 0, False: 0]
  ------------------
  674|       |          /* constant folding */
  675|      0|          data0 = mrb_decode_insn(mrb_prev_pc(s, data0.addr));
  676|      0|          mrb_int n;
  677|      0|          if (data0.a == dst && get_int_operand(s, &data0, &n)) {
  ------------------
  |  Branch (677:15): [True: 0, False: 0]
  |  Branch (677:33): [True: 0, False: 0]
  ------------------
  678|      0|            if ((data.insn == OP_ADDI && !mrb_int_add_overflow(n, data.b, &n)) ||
  ------------------
  |  Branch (678:18): [True: 0, False: 0]
  |  Branch (678:42): [True: 0, False: 0]
  ------------------
  679|      0|                (data.insn == OP_SUBI && !mrb_int_sub_overflow(n, data.b, &n))) {
  ------------------
  |  Branch (679:18): [True: 0, False: 0]
  |  Branch (679:42): [True: 0, False: 0]
  ------------------
  680|      0|              s->pc = addr_pc(s, data0.addr);
  ------------------
  |  |  475|      0|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  681|      0|              gen_int(s, dst, n);
  682|      0|              return;
  683|      0|            }
  684|      0|          }
  685|      0|        }
  686|      0|      }
  687|      0|      genop_2(s, data.insn, dst, data.b);
  688|      0|      return;
  689|  8.50k|    default:
  ------------------
  |  Branch (689:5): [True: 8.50k, False: 207k]
  ------------------
  690|  8.50k|      break;
  691|   215k|    }
  692|   215k|  }
  693|  93.9k| normal:
  694|  93.9k|  genop_2(s, OP_MOVE, dst, src);
  695|  93.9k|  return;
  696|   293k|}
codegen.c:no_peephole:
  490|   498k|{
  491|   498k|  return no_optimize(s) || s->lastlabel == s->pc || s->pc == 0 || s->pc == s->lastpc;
  ------------------
  |  Branch (491:10): [True: 0, False: 498k]
  |  Branch (491:28): [True: 10.8k, False: 487k]
  |  Branch (491:53): [True: 0, False: 487k]
  |  Branch (491:67): [True: 152, False: 487k]
  ------------------
  492|   498k|}
codegen.c:no_optimize:
  330|   719k|{
  331|   719k|  if (s && s->parser && s->parser->no_optimize)
  ------------------
  |  Branch (331:7): [True: 719k, False: 0]
  |  Branch (331:12): [True: 719k, False: 0]
  |  Branch (331:25): [True: 0, False: 719k]
  ------------------
  332|      0|    return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  333|   719k|  return FALSE;
  ------------------
  |  |   51|   719k|#  define FALSE 0
  ------------------
  334|   719k|}
codegen.c:mrb_last_insn:
  480|   470k|{
  481|   470k|  if (s->pc == 0) {
  ------------------
  |  Branch (481:7): [True: 0, False: 470k]
  ------------------
  482|      0|    struct mrb_insn_data data = { OP_NOP, 0 };
  483|      0|    return data;
  484|      0|  }
  485|   470k|  return mrb_decode_insn(&s->iseq[s->lastpc]);
  486|   470k|}
codegen.c:mrb_prev_pc:
  449|   133k|{
  450|   133k|  const mrb_code *prev_pc = NULL;
  451|   133k|  const mrb_code *i = s->iseq;
  452|       |
  453|   103M|  while (i<pc) {
  ------------------
  |  Branch (453:10): [True: 102M, False: 133k]
  ------------------
  454|   102M|    uint8_t insn = i[0];
  455|   102M|    prev_pc = i;
  456|   102M|    switch (insn) {
  457|  19.3M|    case OP_EXT1:
  ------------------
  |  Branch (457:5): [True: 19.3M, False: 83.5M]
  ------------------
  458|  19.3M|      i += mrb_insn_size1[i[1]] + 1;
  459|  19.3M|      break;
  460|   198k|    case OP_EXT2:
  ------------------
  |  Branch (460:5): [True: 198k, False: 102M]
  ------------------
  461|   198k|      i += mrb_insn_size2[i[1]] + 1;
  462|   198k|      break;
  463|   360k|    case OP_EXT3:
  ------------------
  |  Branch (463:5): [True: 360k, False: 102M]
  ------------------
  464|   360k|      i += mrb_insn_size3[i[1]] + 1;
  465|   360k|      break;
  466|  83.0M|    default:
  ------------------
  |  Branch (466:5): [True: 83.0M, False: 19.8M]
  ------------------
  467|  83.0M|      i += mrb_insn_size[insn];
  468|  83.0M|      break;
  469|   102M|    }
  470|   102M|  }
  471|   133k|  return prev_pc;
  472|   133k|}
codegen.c:genop_2SS:
  305|  2.21k|{
  306|  2.21k|  genop_1(s, i, a);
  307|  2.21k|  gen_S(s, b>>16);
  308|  2.21k|  gen_S(s, b&0xffff);
  309|  2.21k|}
codegen.c:get_int_operand:
  753|   328k|{
  754|   328k|  switch (data->insn) {
  755|    955|  case OP_LOADI__1:
  ------------------
  |  Branch (755:3): [True: 955, False: 327k]
  ------------------
  756|    955|    *n = -1;
  757|    955|    return TRUE;
  ------------------
  |  |   54|    955|#  define TRUE 1
  ------------------
  758|       |
  759|  6.04k|  case OP_LOADINEG:
  ------------------
  |  Branch (759:3): [True: 6.04k, False: 322k]
  ------------------
  760|  6.04k|    *n = -data->b;
  761|  6.04k|    return TRUE;
  ------------------
  |  |   54|  6.04k|#  define TRUE 1
  ------------------
  762|       |
  763|   122k|  case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3:
  ------------------
  |  Branch (763:3): [True: 10.4k, False: 317k]
  |  Branch (763:20): [True: 107k, False: 220k]
  |  Branch (763:37): [True: 2.30k, False: 326k]
  |  Branch (763:54): [True: 2.07k, False: 326k]
  ------------------
  764|   131k|  case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7:
  ------------------
  |  Branch (764:3): [True: 1.24k, False: 327k]
  |  Branch (764:20): [True: 1.75k, False: 326k]
  |  Branch (764:37): [True: 4.57k, False: 323k]
  |  Branch (764:54): [True: 1.90k, False: 326k]
  ------------------
  765|   131k|    *n = data->insn - OP_LOADI_0;
  766|   131k|    return TRUE;
  ------------------
  |  |   54|   131k|#  define TRUE 1
  ------------------
  767|       |
  768|  13.7k|  case OP_LOADI:
  ------------------
  |  Branch (768:3): [True: 13.7k, False: 314k]
  ------------------
  769|  15.3k|  case OP_LOADI16:
  ------------------
  |  Branch (769:3): [True: 1.61k, False: 326k]
  ------------------
  770|  15.3k|    *n = (int16_t)data->b;
  771|  15.3k|    return TRUE;
  ------------------
  |  |   54|  15.3k|#  define TRUE 1
  ------------------
  772|       |
  773|  1.89k|  case OP_LOADI32:
  ------------------
  |  Branch (773:3): [True: 1.89k, False: 326k]
  ------------------
  774|  1.89k|    *n = (int32_t)((uint32_t)data->b<<16)+data->c;
  775|  1.89k|    return TRUE;
  ------------------
  |  |   54|  1.89k|#  define TRUE 1
  ------------------
  776|       |
  777|  2.51k|  case OP_LOADL:
  ------------------
  |  Branch (777:3): [True: 2.51k, False: 325k]
  ------------------
  778|  2.51k|    {
  779|  2.51k|      mrb_pool_value *pv = &s->pool[data->b];
  780|       |
  781|  2.51k|      if (pv->tt == IREP_TT_INT32) {
  ------------------
  |  Branch (781:11): [True: 0, False: 2.51k]
  ------------------
  782|      0|        *n = (mrb_int)pv->u.i32;
  783|      0|      }
  784|  2.51k|#ifdef MRB_INT64
  785|  2.51k|      else if (pv->tt == IREP_TT_INT64) {
  ------------------
  |  Branch (785:16): [True: 2.51k, False: 0]
  ------------------
  786|  2.51k|        *n = (mrb_int)pv->u.i64;
  787|  2.51k|      }
  788|      0|#endif
  789|      0|      else {
  790|      0|        return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  791|      0|      }
  792|  2.51k|    }
  793|  2.51k|    return TRUE;
  ------------------
  |  |   54|  2.51k|#  define TRUE 1
  ------------------
  794|       |
  795|   169k|  default:
  ------------------
  |  Branch (795:3): [True: 169k, False: 158k]
  ------------------
  796|   169k|    return FALSE;
  ------------------
  |  |   51|   169k|#  define FALSE 0
  ------------------
  797|   328k|  }
  798|   328k|}
codegen.c:genop_3:
  291|   127k|{
  292|   127k|  genop_2(s, i, a, b);
  293|   127k|  gen_B(s, (uint8_t)c);
  294|   127k|}
codegen.c:new_sym:
 1135|   237k|{
 1136|   237k|  int i, len;
 1137|       |
 1138|   237k|  mrb_assert(s->irep);
  ------------------
  |  |   68|   237k|#define mrb_assert(p) ((void)0)
  ------------------
 1139|       |
 1140|   237k|  len = s->irep->slen;
 1141|   777k|  for (i=0; i<len; i++) {
  ------------------
  |  Branch (1141:13): [True: 764k, False: 13.1k]
  ------------------
 1142|   764k|    if (s->syms[i] == sym) return i;
  ------------------
  |  Branch (1142:9): [True: 224k, False: 540k]
  ------------------
 1143|   764k|  }
 1144|  13.1k|  if (s->irep->slen >= s->scapa) {
  ------------------
  |  Branch (1144:7): [True: 0, False: 13.1k]
  ------------------
 1145|      0|    s->scapa *= 2;
 1146|      0|    if (s->scapa > 0xffff) {
  ------------------
  |  Branch (1146:9): [True: 0, False: 0]
  ------------------
 1147|      0|      codegen_error(s, "too many symbols");
 1148|      0|    }
 1149|      0|    s->syms = (mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->scapa);
 1150|      0|  }
 1151|  13.1k|  s->syms[s->irep->slen] = sym;
 1152|  13.1k|  return s->irep->slen++;
 1153|   237k|}
codegen.c:genop_2:
  261|   692k|{
  262|   692k|  s->lastpc = s->pc;
  263|   692k|  check_no_ext_ops(s, a, b);
  264|   692k|  if (a > 0xff && b > 0xff) {
  ------------------
  |  Branch (264:7): [True: 153k, False: 539k]
  |  Branch (264:19): [True: 3.54k, False: 149k]
  ------------------
  265|  3.54k|    gen_B(s, OP_EXT3);
  266|  3.54k|    gen_B(s, i);
  267|  3.54k|    gen_S(s, a);
  268|  3.54k|    gen_S(s, b);
  269|  3.54k|  }
  270|   688k|  else if (b > 0xff) {
  ------------------
  |  Branch (270:12): [True: 2.76k, False: 686k]
  ------------------
  271|  2.76k|    gen_B(s, OP_EXT2);
  272|  2.76k|    gen_B(s, i);
  273|  2.76k|    gen_B(s, (uint8_t)a);
  274|  2.76k|    gen_S(s, b);
  275|  2.76k|  }
  276|   686k|  else if (a > 0xff) {
  ------------------
  |  Branch (276:12): [True: 149k, False: 536k]
  ------------------
  277|   149k|    gen_B(s, OP_EXT1);
  278|   149k|    gen_B(s, i);
  279|   149k|    gen_S(s, a);
  280|   149k|    gen_B(s, (uint8_t)b);
  281|   149k|  }
  282|   536k|  else {
  283|   536k|    gen_B(s, i);
  284|   536k|    gen_B(s, (uint8_t)a);
  285|   536k|    gen_B(s, (uint8_t)b);
  286|   536k|  }
  287|   692k|}
codegen.c:genjmp2:
  527|  49.6k|{
  528|  49.6k|  uint32_t pos;
  529|       |
  530|  49.6k|  if (!no_peephole(s) && !val) {
  ------------------
  |  Branch (530:7): [True: 49.0k, False: 639]
  |  Branch (530:26): [True: 32.0k, False: 16.9k]
  ------------------
  531|  32.0k|    struct mrb_insn_data data = mrb_last_insn(s);
  532|       |
  533|  32.0k|    switch (data.insn) {
  ------------------
  |  Branch (533:13): [True: 26.3k, False: 5.74k]
  ------------------
  534|  2.00k|    case OP_MOVE:
  ------------------
  |  Branch (534:5): [True: 2.00k, False: 30.0k]
  ------------------
  535|  2.00k|      if (data.a == a && data.a > s->nlocals) {
  ------------------
  |  Branch (535:11): [True: 2.00k, False: 0]
  |  Branch (535:26): [True: 0, False: 2.00k]
  ------------------
  536|      0|        rewind_pc(s);
  ------------------
  |  |  476|      0|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  537|      0|        a = data.b;
  538|      0|      }
  539|  2.00k|      break;
  540|      0|    case OP_LOADNIL:
  ------------------
  |  Branch (540:5): [True: 0, False: 32.0k]
  ------------------
  541|      0|    case OP_LOADF:
  ------------------
  |  Branch (541:5): [True: 0, False: 32.0k]
  ------------------
  542|      0|      if (data.a == a || data.a > s->nlocals) {
  ------------------
  |  Branch (542:11): [True: 0, False: 0]
  |  Branch (542:26): [True: 0, False: 0]
  ------------------
  543|      0|        s->pc = addr_pc(s, data.addr);
  ------------------
  |  |  475|      0|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  544|      0|        if (i == OP_JMPNOT || (i == OP_JMPNIL && data.insn == OP_LOADNIL)) {
  ------------------
  |  Branch (544:13): [True: 0, False: 0]
  |  Branch (544:32): [True: 0, False: 0]
  |  Branch (544:50): [True: 0, False: 0]
  ------------------
  545|      0|          return genjmp(s, OP_JMP, pc);
  546|      0|        }
  547|      0|        else {                  /* OP_JMPIF */
  548|      0|          return JMPLINK_START;
  ------------------
  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  ------------------
  549|      0|        }
  550|      0|      }
  551|      0|      break;
  552|    530|    case OP_LOADT: case OP_LOADI: case OP_LOADINEG: case OP_LOADI__1:
  ------------------
  |  Branch (552:5): [True: 0, False: 32.0k]
  |  Branch (552:20): [True: 313, False: 31.7k]
  |  Branch (552:35): [True: 180, False: 31.8k]
  |  Branch (552:53): [True: 37, False: 32.0k]
  ------------------
  553|  2.48k|    case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3:
  ------------------
  |  Branch (553:5): [True: 427, False: 31.6k]
  |  Branch (553:22): [True: 994, False: 31.0k]
  |  Branch (553:39): [True: 218, False: 31.8k]
  |  Branch (553:56): [True: 313, False: 31.7k]
  ------------------
  554|  3.73k|    case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7:
  ------------------
  |  Branch (554:5): [True: 410, False: 31.6k]
  |  Branch (554:22): [True: 254, False: 31.8k]
  |  Branch (554:39): [True: 353, False: 31.7k]
  |  Branch (554:56): [True: 238, False: 31.8k]
  ------------------
  555|  3.73k|      if (data.a == a || data.a > s->nlocals) {
  ------------------
  |  Branch (555:11): [True: 3.73k, False: 0]
  |  Branch (555:26): [True: 0, False: 0]
  ------------------
  556|  3.73k|        s->pc = addr_pc(s, data.addr);
  ------------------
  |  |  475|  3.73k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  557|  3.73k|        if (i == OP_JMPIF) {
  ------------------
  |  Branch (557:13): [True: 189, False: 3.54k]
  ------------------
  558|    189|          return genjmp(s, OP_JMP, pc);
  559|    189|        }
  560|  3.54k|        else {                  /* OP_JMPNOT and OP_JMPNIL */
  561|  3.54k|          return JMPLINK_START;
  ------------------
  |  |  494|  3.54k|#define JMPLINK_START UINT32_MAX
  ------------------
  562|  3.54k|        }
  563|  3.73k|      }
  564|      0|      break;
  565|  32.0k|    }
  566|  32.0k|  }
  567|       |
  568|  45.9k|  if (a > 0xff) {
  ------------------
  |  Branch (568:7): [True: 3.54k, False: 42.4k]
  ------------------
  569|  3.54k|    check_no_ext_ops(s, a, 0);
  570|  3.54k|    gen_B(s, OP_EXT1);
  571|  3.54k|    genop_0(s, i);
  572|  3.54k|    gen_S(s, a);
  573|  3.54k|  }
  574|  42.4k|  else {
  575|  42.4k|    genop_0(s, i);
  576|  42.4k|    gen_B(s, (uint8_t)a);
  577|  42.4k|  }
  578|  45.9k|  pos = s->pc;
  579|  45.9k|  gen_jmpdst(s, pc);
  580|  45.9k|  return pos;
  581|  49.6k|}
codegen.c:gen_assignment:
 1809|   244k|{
 1810|   244k|  int idx;
 1811|   244k|  int type = nint(tree->car);
  ------------------
  |  | 1227|   244k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 1812|       |
 1813|   244k|  switch (type) {
 1814|      0|  case NODE_GVAR:
  ------------------
  |  Branch (1814:3): [True: 0, False: 244k]
  ------------------
 1815|      0|  case NODE_ARG:
  ------------------
  |  Branch (1815:3): [True: 0, False: 244k]
  ------------------
 1816|   213k|  case NODE_LVAR:
  ------------------
  |  Branch (1816:3): [True: 213k, False: 30.8k]
  ------------------
 1817|   244k|  case NODE_IVAR:
  ------------------
  |  Branch (1817:3): [True: 30.8k, False: 213k]
  ------------------
 1818|   244k|  case NODE_CVAR:
  ------------------
  |  Branch (1818:3): [True: 0, False: 244k]
  ------------------
 1819|   244k|  case NODE_CONST:
  ------------------
  |  Branch (1819:3): [True: 0, False: 244k]
  ------------------
 1820|   244k|  case NODE_NIL:
  ------------------
  |  Branch (1820:3): [True: 0, False: 244k]
  ------------------
 1821|   244k|  case NODE_MASGN:
  ------------------
  |  Branch (1821:3): [True: 0, False: 244k]
  ------------------
 1822|   244k|    if (rhs) {
  ------------------
  |  Branch (1822:9): [True: 213k, False: 30.8k]
  ------------------
 1823|   213k|      codegen(s, rhs, VAL);
  ------------------
  |  |  326|   213k|#define VAL    1
  ------------------
 1824|   213k|      pop();
  ------------------
  |  |  988|   213k|#define pop() pop_n_(s,1)
  ------------------
 1825|   213k|      sp = cursp();
  ------------------
  |  |  990|   213k|#define cursp() (s->sp)
  ------------------
 1826|   213k|    }
 1827|   244k|    break;
 1828|       |
 1829|      0|  case NODE_COLON2:
  ------------------
  |  Branch (1829:3): [True: 0, False: 244k]
  ------------------
 1830|      0|  case NODE_COLON3:
  ------------------
  |  Branch (1830:3): [True: 0, False: 244k]
  ------------------
 1831|      0|  case NODE_CALL:
  ------------------
  |  Branch (1831:3): [True: 0, False: 244k]
  ------------------
 1832|      0|  case NODE_SCALL:
  ------------------
  |  Branch (1832:3): [True: 0, False: 244k]
  ------------------
 1833|       |    /* keep evaluation order */
 1834|      0|    break;
 1835|       |
 1836|      0|  case NODE_NVAR:
  ------------------
  |  Branch (1836:3): [True: 0, False: 244k]
  ------------------
 1837|       |    /* never happens; should have already checked in the parser */
 1838|      0|    codegen_error(s, "Can't assign to numbered parameter");
 1839|      0|    break;
 1840|       |
 1841|      0|  default:
  ------------------
  |  Branch (1841:3): [True: 0, False: 244k]
  ------------------
 1842|      0|    codegen_error(s, "unknown lhs");
 1843|      0|    break;
 1844|   244k|  }
 1845|       |
 1846|   244k|  tree = tree->cdr;
 1847|   244k|  switch (type) {
 1848|      0|  case NODE_GVAR:
  ------------------
  |  Branch (1848:3): [True: 0, False: 244k]
  ------------------
 1849|      0|    gen_setxv(s, OP_SETGV, sp, nsym(tree), val);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1850|      0|    break;
 1851|      0|  case NODE_ARG:
  ------------------
  |  Branch (1851:3): [True: 0, False: 244k]
  ------------------
 1852|   213k|  case NODE_LVAR:
  ------------------
  |  Branch (1852:3): [True: 213k, False: 30.8k]
  ------------------
 1853|   213k|    idx = lv_idx(s, nsym(tree));
  ------------------
  |  | 1229|   213k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1854|   213k|    if (idx > 0) {
  ------------------
  |  Branch (1854:9): [True: 213k, False: 0]
  ------------------
 1855|   213k|      if (idx != sp) {
  ------------------
  |  Branch (1855:11): [True: 213k, False: 0]
  ------------------
 1856|   213k|        gen_move(s, idx, sp, val);
 1857|   213k|      }
 1858|   213k|      break;
 1859|   213k|    }
 1860|      0|    else {                      /* upvar */
 1861|      0|      gen_setupvar(s, sp, nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1862|      0|    }
 1863|      0|    break;
 1864|  30.8k|  case NODE_IVAR:
  ------------------
  |  Branch (1864:3): [True: 30.8k, False: 213k]
  ------------------
 1865|  30.8k|    gen_setxv(s, OP_SETIV, sp, nsym(tree), val);
  ------------------
  |  | 1229|  30.8k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1866|  30.8k|    break;
 1867|      0|  case NODE_CVAR:
  ------------------
  |  Branch (1867:3): [True: 0, False: 244k]
  ------------------
 1868|      0|    gen_setxv(s, OP_SETCV, sp, nsym(tree), val);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1869|      0|    break;
 1870|      0|  case NODE_CONST:
  ------------------
  |  Branch (1870:3): [True: 0, False: 244k]
  ------------------
 1871|      0|    gen_setxv(s, OP_SETCONST, sp, nsym(tree), val);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1872|      0|    break;
 1873|      0|  case NODE_COLON2:
  ------------------
  |  Branch (1873:3): [True: 0, False: 244k]
  ------------------
 1874|      0|  case NODE_COLON3:
  ------------------
  |  Branch (1874:3): [True: 0, False: 244k]
  ------------------
 1875|      0|    if (sp) {
  ------------------
  |  Branch (1875:9): [True: 0, False: 0]
  ------------------
 1876|      0|      gen_move(s, cursp(), sp, 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1877|      0|    }
 1878|      0|    sp = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1879|      0|    push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1880|      0|    if (type == NODE_COLON2) {
  ------------------
  |  Branch (1880:9): [True: 0, False: 0]
  ------------------
 1881|      0|      codegen(s, tree->car, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1882|      0|      idx = new_sym(s, nsym(tree->cdr));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1883|      0|    }
 1884|      0|    else {   /* NODE_COLON3 */
 1885|      0|      genop_1(s, OP_OCLASS, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1886|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1887|      0|      idx = new_sym(s, nsym(tree));
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1888|      0|    }
 1889|      0|    if (rhs) {
  ------------------
  |  Branch (1889:9): [True: 0, False: 0]
  ------------------
 1890|      0|      codegen(s, rhs, VAL); pop();
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
                    codegen(s, rhs, VAL); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1891|      0|      gen_move(s, sp, cursp(), 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1892|      0|    }
 1893|      0|    pop_n(2);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1894|      0|    genop_2(s, OP_SETMCNST, sp, idx);
 1895|      0|    break;
 1896|       |
 1897|      0|  case NODE_CALL:
  ------------------
  |  Branch (1897:3): [True: 0, False: 244k]
  ------------------
 1898|      0|  case NODE_SCALL:
  ------------------
  |  Branch (1898:3): [True: 0, False: 244k]
  ------------------
 1899|      0|    {
 1900|      0|      int noself = 0, safe = (type == NODE_SCALL), skip = 0, top, call, n = 0;
 1901|      0|      mrb_sym mid = nsym(tree->cdr->car);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1902|       |
 1903|      0|      top = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1904|      0|      if (val || sp == cursp()) {
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
  |  Branch (1904:11): [True: 0, False: 0]
  |  Branch (1904:18): [True: 0, False: 0]
  ------------------
 1905|      0|        push();                   /* room for retval */
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1906|      0|      }
 1907|      0|      call = cursp();
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1908|      0|      if (!tree->car) {
  ------------------
  |  Branch (1908:11): [True: 0, False: 0]
  ------------------
 1909|      0|        noself = 1;
 1910|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1911|      0|      }
 1912|      0|      else {
 1913|      0|        codegen(s, tree->car, VAL); /* receiver */
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1914|      0|      }
 1915|      0|      if (safe) {
  ------------------
  |  Branch (1915:11): [True: 0, False: 0]
  ------------------
 1916|      0|        int recv = cursp()-1;
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1917|      0|        gen_move(s, cursp(), recv, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1918|      0|        skip = genjmp2_0(s, OP_JMPNIL, cursp(), val);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 1919|      0|      }
 1920|      0|      tree = tree->cdr->cdr->car;
 1921|      0|      if (tree) {
  ------------------
  |  Branch (1921:11): [True: 0, False: 0]
  ------------------
 1922|      0|        if (tree->car) {            /* positional arguments */
  ------------------
  |  Branch (1922:13): [True: 0, False: 0]
  ------------------
 1923|      0|          n = gen_values(s, tree->car, VAL, (tree->cdr->car)?13:14);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
  |  Branch (1923:45): [True: 0, False: 0]
  ------------------
 1924|      0|          if (n < 0) {              /* variable length */
  ------------------
  |  Branch (1924:15): [True: 0, False: 0]
  ------------------
 1925|      0|            n = 15;
 1926|      0|            push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1927|      0|          }
 1928|      0|        }
 1929|      0|        if (tree->cdr->car) {       /* keyword arguments */
  ------------------
  |  Branch (1929:13): [True: 0, False: 0]
  ------------------
 1930|      0|          if (n == 13 || n == 14) {
  ------------------
  |  Branch (1930:15): [True: 0, False: 0]
  |  Branch (1930:26): [True: 0, False: 0]
  ------------------
 1931|      0|            pop_n(n);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1932|      0|            genop_2(s, OP_ARRAY, cursp(), n);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1933|      0|            push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1934|      0|            n = 15;
 1935|      0|          }
 1936|      0|          gen_hash(s, tree->cdr->car->cdr, VAL, 0);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1937|      0|          if (n < 14) {
  ------------------
  |  Branch (1937:15): [True: 0, False: 0]
  ------------------
 1938|      0|            n++;
 1939|      0|          }
 1940|      0|          else {
 1941|      0|            pop_n(2);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1942|      0|            genop_2(s, OP_ARYPUSH, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1943|      0|          }
 1944|      0|          push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1945|      0|        }
 1946|      0|      }
 1947|      0|      if (rhs) {
  ------------------
  |  Branch (1947:11): [True: 0, False: 0]
  ------------------
 1948|      0|        codegen(s, rhs, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1949|      0|        pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1950|      0|      }
 1951|      0|      else {
 1952|      0|        gen_move(s, cursp(), sp, 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1953|      0|      }
 1954|      0|      if (val) {
  ------------------
  |  Branch (1954:11): [True: 0, False: 0]
  ------------------
 1955|      0|        gen_move(s, top, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1956|      0|      }
 1957|      0|      if (n < 15) {
  ------------------
  |  Branch (1957:11): [True: 0, False: 0]
  ------------------
 1958|      0|        n++;
 1959|      0|        if (n == 15) {
  ------------------
  |  Branch (1959:13): [True: 0, False: 0]
  ------------------
 1960|      0|          pop_n(14);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1961|      0|          genop_2(s, OP_ARRAY, cursp(), 15);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1962|      0|        }
 1963|      0|      }
 1964|      0|      else {
 1965|      0|        pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1966|      0|        genop_2(s, OP_ARYPUSH, cursp(), 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1967|      0|      }
 1968|      0|      push(); pop();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
                    push(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1969|      0|      s->sp = call;
 1970|      0|      if (mid == MRB_OPSYM_2(s->mrb, aref) && n == 2) {
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1970:11): [True: 0, False: 0]
  |  Branch (1970:47): [True: 0, False: 0]
  ------------------
 1971|      0|        push_n(4); pop_n(4); /* self + idx + value + (invisible block for OP_SEND) */
  ------------------
  |  |  987|      0|#define push_n(n) push_n_(s,n)
  ------------------
                      push_n(4); pop_n(4); /* self + idx + value + (invisible block for OP_SEND) */
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1972|      0|        genop_1(s, OP_SETIDX, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1973|      0|      }
 1974|      0|      else {
 1975|      0|        int st = 2 /* self + block */ +
 1976|      0|                 (((n >> 0) & 0x0f) < 15 ? ((n >> 0) & 0x0f)     : 1) +
  ------------------
  |  Branch (1976:19): [True: 0, False: 0]
  ------------------
 1977|      0|                 (((n >> 4) & 0x0f) < 15 ? ((n >> 4) & 0x0f) * 2 : 1);
  ------------------
  |  Branch (1977:19): [True: 0, False: 0]
  ------------------
 1978|      0|        push_n(st); pop_n(st);
  ------------------
  |  |  987|      0|#define push_n(n) push_n_(s,n)
  ------------------
                      push_n(st); pop_n(st);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1979|      0|        genop_3(s, noself ? OP_SSEND : OP_SEND, cursp(), new_sym(s, attrsym(s, mid)), n);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
  |  Branch (1979:20): [True: 0, False: 0]
  ------------------
 1980|      0|      }
 1981|      0|      if (safe) {
  ------------------
  |  Branch (1981:11): [True: 0, False: 0]
  ------------------
 1982|      0|        dispatch(s, skip);
 1983|      0|      }
 1984|      0|      s->sp = top;
 1985|      0|    }
 1986|      0|    break;
 1987|       |
 1988|      0|  case NODE_MASGN:
  ------------------
  |  Branch (1988:3): [True: 0, False: 244k]
  ------------------
 1989|      0|    gen_massignment(s, tree->car, sp, val);
 1990|      0|    break;
 1991|       |
 1992|       |  /* splat without assignment */
 1993|      0|  case NODE_NIL:
  ------------------
  |  Branch (1993:3): [True: 0, False: 244k]
  ------------------
 1994|      0|    break;
 1995|       |
 1996|      0|  default:
  ------------------
  |  Branch (1996:3): [True: 0, False: 244k]
  ------------------
 1997|      0|    codegen_error(s, "unknown lhs");
 1998|      0|    break;
 1999|   244k|  }
 2000|   244k|  if (val) push();
  ------------------
  |  |  986|  15.7k|#define push() push_n_(s,1)
  ------------------
  |  Branch (2000:7): [True: 15.7k, False: 228k]
  ------------------
 2001|   244k|}
codegen.c:gen_setxv:
 1157|  30.8k|{
 1158|  30.8k|  int idx = new_sym(s, sym);
 1159|  30.8k|  if (!val && !no_peephole(s)) {
  ------------------
  |  Branch (1159:7): [True: 21.0k, False: 9.77k]
  |  Branch (1159:15): [True: 14.7k, False: 6.25k]
  ------------------
 1160|  14.7k|    struct mrb_insn_data data = mrb_last_insn(s);
 1161|  14.7k|    if (data.insn == OP_MOVE && data.a == dst) {
  ------------------
  |  Branch (1161:9): [True: 4.74k, False: 10.0k]
  |  Branch (1161:33): [True: 316, False: 4.43k]
  ------------------
 1162|    316|      dst = data.b;
 1163|    316|      rewind_pc(s);
  ------------------
  |  |  476|    316|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
 1164|    316|    }
 1165|  14.7k|  }
 1166|  30.8k|  genop_2(s, op, dst, idx);
 1167|  30.8k|}
codegen.c:lambda_body:
 1343|  1.73k|{
 1344|  1.73k|  codegen_scope *parent = s;
 1345|  1.73k|  s = scope_new(s->mrb, s, tree->car);
 1346|       |
 1347|  1.73k|  s->mscope = !blk;
 1348|       |
 1349|  1.73k|  if (blk) {
  ------------------
  |  Branch (1349:7): [True: 0, False: 1.73k]
  ------------------
 1350|      0|    struct loopinfo *lp = loop_push(s, LOOP_BLOCK);
 1351|      0|    lp->pc0 = new_label(s);
 1352|      0|  }
 1353|  1.73k|  tree = tree->cdr;
 1354|  1.73k|  if (tree->car == NULL) {
  ------------------
  |  Branch (1354:7): [True: 0, False: 1.73k]
  ------------------
 1355|      0|    genop_W(s, OP_ENTER, 0);
 1356|      0|    s->ainfo = 0;
 1357|      0|  }
 1358|  1.73k|  else {
 1359|  1.73k|    mrb_aspec a;
 1360|  1.73k|    int ma, oa, ra, pa, ka, kd, ba, i;
 1361|  1.73k|    uint32_t pos;
 1362|  1.73k|    node *opt;
 1363|  1.73k|    node *margs, *pargs;
 1364|  1.73k|    node *tail;
 1365|       |
 1366|       |    /* mandatory arguments */
 1367|  1.73k|    ma = node_len(tree->car->car);
 1368|  1.73k|    margs = tree->car->car;
 1369|  1.73k|    tail = tree->car->cdr->cdr->cdr->cdr;
 1370|       |
 1371|       |    /* optional arguments */
 1372|  1.73k|    oa = node_len(tree->car->cdr->car);
 1373|       |    /* rest argument? */
 1374|  1.73k|    ra = tree->car->cdr->cdr->car ? 1 : 0;
  ------------------
  |  Branch (1374:10): [True: 0, False: 1.73k]
  ------------------
 1375|       |    /* mandatory arguments after rest argument */
 1376|  1.73k|    pa = node_len(tree->car->cdr->cdr->cdr->car);
 1377|  1.73k|    pargs = tree->car->cdr->cdr->cdr->car;
 1378|       |    /* keyword arguments */
 1379|  1.73k|    ka = tail? node_len(tail->cdr->car) : 0;
  ------------------
  |  Branch (1379:10): [True: 0, False: 1.73k]
  ------------------
 1380|       |    /* keyword dictionary? */
 1381|  1.73k|    kd = tail && tail->cdr->cdr->car? 1 : 0;
  ------------------
  |  Branch (1381:10): [True: 0, False: 1.73k]
  |  Branch (1381:18): [True: 0, False: 0]
  ------------------
 1382|       |    /* block argument? */
 1383|  1.73k|    ba = tail && tail->cdr->cdr->cdr->car ? 1 : 0;
  ------------------
  |  Branch (1383:10): [True: 0, False: 1.73k]
  |  Branch (1383:18): [True: 0, False: 0]
  ------------------
 1384|       |
 1385|  1.73k|    if (ma > 0x1f || oa > 0x1f || pa > 0x1f || ka > 0x1f) {
  ------------------
  |  Branch (1385:9): [True: 0, False: 1.73k]
  |  Branch (1385:22): [True: 0, False: 1.73k]
  |  Branch (1385:35): [True: 0, False: 1.73k]
  |  Branch (1385:48): [True: 0, False: 1.73k]
  ------------------
 1386|      0|      codegen_error(s, "too many formal arguments");
 1387|      0|    }
 1388|       |    /* (23bits = 5:5:1:5:5:1:1) */
 1389|  1.73k|    a = MRB_ARGS_REQ(ma)
  ------------------
  |  |  877|  1.73k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1390|  1.73k|      | MRB_ARGS_OPT(oa)
  ------------------
  |  |  885|  1.73k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1391|  1.73k|      | (ra? MRB_ARGS_REST() : 0)
  ------------------
  |  |  898|      0|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  ------------------
  |  Branch (1391:10): [True: 0, False: 1.73k]
  ------------------
 1392|  1.73k|      | MRB_ARGS_POST(pa)
  ------------------
  |  |  901|  1.73k|#define MRB_ARGS_POST(n)    ((mrb_aspec)((n)&0x1f) << 7)
  ------------------
 1393|  1.73k|      | MRB_ARGS_KEY(ka, kd)
  ------------------
  |  |  904|  1.73k|#define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))
  |  |  ------------------
  |  |  |  Branch (904:64): [True: 0, False: 1.73k]
  |  |  ------------------
  ------------------
 1394|  1.73k|      | (ba? MRB_ARGS_BLOCK() : 0);
  ------------------
  |  |  909|      0|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  |  Branch (1394:10): [True: 0, False: 1.73k]
  ------------------
 1395|  1.73k|    genop_W(s, OP_ENTER, a);
 1396|       |    /* (12bits = 5:1:5:1) */
 1397|  1.73k|    s->ainfo = (((ma+oa) & 0x3f) << 7)
 1398|  1.73k|      | ((ra & 0x1) << 6)
 1399|  1.73k|      | ((pa & 0x1f) << 1)
 1400|  1.73k|      | ((ka | kd) ? 1 : 0);
  ------------------
  |  Branch (1400:10): [True: 0, False: 1.73k]
  ------------------
 1401|       |    /* generate jump table for optional arguments initializer */
 1402|  1.73k|    pos = new_label(s);
 1403|  1.73k|    for (i=0; i<oa; i++) {
  ------------------
  |  Branch (1403:15): [True: 0, False: 1.73k]
  ------------------
 1404|      0|      new_label(s);
 1405|      0|      genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 1406|      0|    }
 1407|  1.73k|    if (oa > 0) {
  ------------------
  |  Branch (1407:9): [True: 0, False: 1.73k]
  ------------------
 1408|      0|      genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 1409|      0|    }
 1410|  1.73k|    opt = tree->car->cdr->car;
 1411|  1.73k|    i = 0;
 1412|  1.73k|    while (opt) {
  ------------------
  |  Branch (1412:12): [True: 0, False: 1.73k]
  ------------------
 1413|      0|      int idx;
 1414|      0|      mrb_sym id = nsym(opt->car->car);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1415|       |
 1416|      0|      dispatch(s, pos+i*3+1);
 1417|      0|      codegen(s, opt->car->cdr, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1418|      0|      pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1419|      0|      idx = lv_idx(s, id);
 1420|      0|      if (idx > 0) {
  ------------------
  |  Branch (1420:11): [True: 0, False: 0]
  ------------------
 1421|      0|        gen_move(s, idx, cursp(), 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1422|      0|      }
 1423|      0|      else {
 1424|      0|        gen_getupvar(s, cursp(), id);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1425|      0|      }
 1426|      0|      i++;
 1427|      0|      opt = opt->cdr;
 1428|      0|    }
 1429|  1.73k|    if (oa > 0) {
  ------------------
  |  Branch (1429:9): [True: 0, False: 1.73k]
  ------------------
 1430|      0|      dispatch(s, pos+i*3+1);
 1431|      0|    }
 1432|       |
 1433|       |    /* keyword arguments */
 1434|  1.73k|    if (tail) {
  ------------------
  |  Branch (1434:9): [True: 0, False: 1.73k]
  ------------------
 1435|      0|      node *kwds = tail->cdr->car;
 1436|      0|      int kwrest = 0;
 1437|       |
 1438|      0|      if (tail->cdr->cdr->car) {
  ------------------
  |  Branch (1438:11): [True: 0, False: 0]
  ------------------
 1439|      0|        kwrest = 1;
 1440|      0|      }
 1441|      0|      mrb_assert(nint(tail->car) == NODE_ARGS_TAIL);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1442|      0|      mrb_assert(node_len(tail) == 4);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1443|       |
 1444|      0|      while (kwds) {
  ------------------
  |  Branch (1444:14): [True: 0, False: 0]
  ------------------
 1445|      0|        int jmpif_key_p, jmp_def_set = -1;
 1446|      0|        node *kwd = kwds->car, *def_arg = kwd->cdr->cdr->car;
 1447|      0|        mrb_sym kwd_sym = nsym(kwd->cdr->car);
  ------------------
  |  | 1229|      0|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1448|       |
 1449|      0|        mrb_assert(nint(kwd->car) == NODE_KW_ARG);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1450|       |
 1451|      0|        if (def_arg) {
  ------------------
  |  Branch (1451:13): [True: 0, False: 0]
  ------------------
 1452|      0|          int idx;
 1453|      0|          genop_2(s, OP_KEY_P, lv_idx(s, kwd_sym), new_sym(s, kwd_sym));
 1454|      0|          jmpif_key_p = genjmp2_0(s, OP_JMPIF, lv_idx(s, kwd_sym), NOVAL);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 1455|      0|          codegen(s, def_arg, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1456|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1457|      0|          idx = lv_idx(s, kwd_sym);
 1458|      0|          if (idx > 0) {
  ------------------
  |  Branch (1458:15): [True: 0, False: 0]
  ------------------
 1459|      0|            gen_move(s, idx, cursp(), 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1460|      0|          }
 1461|      0|          else {
 1462|      0|            gen_getupvar(s, cursp(), kwd_sym);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1463|      0|          }
 1464|      0|          jmp_def_set = genjmp_0(s, OP_JMP);
  ------------------
  |  |  523|      0|#define genjmp_0(s,i) genjmp(s,i,JMPLINK_START)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 1465|      0|          dispatch(s, jmpif_key_p);
 1466|      0|        }
 1467|      0|        genop_2(s, OP_KARG, lv_idx(s, kwd_sym), new_sym(s, kwd_sym));
 1468|      0|        if (jmp_def_set != -1) {
  ------------------
  |  Branch (1468:13): [True: 0, False: 0]
  ------------------
 1469|      0|          dispatch(s, jmp_def_set);
 1470|      0|        }
 1471|      0|        i++;
 1472|       |
 1473|      0|        kwds = kwds->cdr;
 1474|      0|      }
 1475|      0|      if (tail->cdr->car && !kwrest) {
  ------------------
  |  Branch (1475:11): [True: 0, False: 0]
  |  Branch (1475:29): [True: 0, False: 0]
  ------------------
 1476|      0|        genop_0(s, OP_KEYEND);
 1477|      0|      }
 1478|      0|    }
 1479|       |
 1480|       |    /* argument destructuring */
 1481|  1.73k|    if (margs) {
  ------------------
  |  Branch (1481:9): [True: 0, False: 1.73k]
  ------------------
 1482|      0|      node *n = margs;
 1483|       |
 1484|      0|      pos = 1;
 1485|      0|      while (n) {
  ------------------
  |  Branch (1485:14): [True: 0, False: 0]
  ------------------
 1486|      0|        if (nint(n->car->car) == NODE_MASGN) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (1486:13): [True: 0, False: 0]
  ------------------
 1487|      0|          gen_massignment(s, n->car->cdr->car, pos, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 1488|      0|        }
 1489|      0|        pos++;
 1490|      0|        n = n->cdr;
 1491|      0|      }
 1492|      0|    }
 1493|  1.73k|    if (pargs) {
  ------------------
  |  Branch (1493:9): [True: 0, False: 1.73k]
  ------------------
 1494|      0|      node *n = pargs;
 1495|       |
 1496|      0|      pos = ma+oa+ra+1;
 1497|      0|      while (n) {
  ------------------
  |  Branch (1497:14): [True: 0, False: 0]
  ------------------
 1498|      0|        if (nint(n->car->car) == NODE_MASGN) {
  ------------------
  |  | 1227|      0|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (1498:13): [True: 0, False: 0]
  ------------------
 1499|      0|          gen_massignment(s, n->car->cdr->car, pos, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 1500|      0|        }
 1501|      0|        pos++;
 1502|      0|        n = n->cdr;
 1503|      0|      }
 1504|      0|    }
 1505|  1.73k|  }
 1506|       |
 1507|  1.73k|  codegen(s, tree->cdr->car, VAL);
  ------------------
  |  |  326|  1.73k|#define VAL    1
  ------------------
 1508|  1.73k|  pop();
  ------------------
  |  |  988|  1.73k|#define pop() pop_n_(s,1)
  ------------------
 1509|  1.73k|  if (s->pc > 0) {
  ------------------
  |  Branch (1509:7): [True: 1.72k, False: 4]
  ------------------
 1510|  1.72k|    gen_return(s, OP_RETURN, cursp());
  ------------------
  |  |  990|  1.72k|#define cursp() (s->sp)
  ------------------
 1511|  1.72k|  }
 1512|  1.73k|  if (blk) {
  ------------------
  |  Branch (1512:7): [True: 0, False: 1.73k]
  ------------------
 1513|      0|    loop_pop(s, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 1514|      0|  }
 1515|  1.73k|  scope_finish(s);
 1516|  1.73k|  return parent->irep->rlen - 1;
 1517|  1.73k|}
codegen.c:genop_W:
  313|  1.73k|{
  314|  1.73k|  uint8_t a1 = (a>>16) & 0xff;
  315|  1.73k|  uint8_t a2 = (a>>8) & 0xff;
  316|  1.73k|  uint8_t a3 = a & 0xff;
  317|       |
  318|  1.73k|  s->lastpc = s->pc;
  319|  1.73k|  gen_B(s, i);
  320|  1.73k|  gen_B(s, a1);
  321|  1.73k|  gen_B(s, a2);
  322|  1.73k|  gen_B(s, a3);
  323|  1.73k|}
codegen.c:scope_finish:
 3896|  3.26k|{
 3897|  3.26k|  mrb_state *mrb = s->mrb;
 3898|  3.26k|  mrb_irep *irep = s->irep;
 3899|       |
 3900|  3.26k|  if (s->nlocals > 0xff) {
  ------------------
  |  Branch (3900:7): [True: 185, False: 3.08k]
  ------------------
 3901|    185|    codegen_error(s, "too many local variables");
 3902|    185|  }
 3903|  3.26k|  irep->flags = 0;
 3904|  3.26k|  if (s->iseq) {
  ------------------
  |  Branch (3904:7): [True: 3.08k, False: 185]
  ------------------
 3905|  3.08k|    size_t catchsize = sizeof(struct mrb_irep_catch_handler) * irep->clen;
 3906|  3.08k|    irep->iseq = (const mrb_code*)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc + catchsize);
 3907|  3.08k|    irep->ilen = s->pc;
 3908|  3.08k|    if (irep->clen > 0) {
  ------------------
  |  Branch (3908:9): [True: 0, False: 3.08k]
  ------------------
 3909|      0|      memcpy((void*)(irep->iseq + irep->ilen), s->catch_table, catchsize);
 3910|      0|    }
 3911|  3.08k|  }
 3912|    185|  else {
 3913|    185|    irep->clen = 0;
 3914|    185|  }
 3915|  3.26k|  mrb_free(s->mrb, s->catch_table);
 3916|  3.26k|  s->catch_table = NULL;
 3917|  3.26k|  irep->pool = (const mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*irep->plen);
 3918|  3.26k|  irep->syms = (const mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*irep->slen);
 3919|  3.26k|  irep->reps = (const mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*irep->rlen);
 3920|  3.26k|  if (s->filename_sym) {
  ------------------
  |  Branch (3920:7): [True: 0, False: 3.26k]
  ------------------
 3921|      0|    mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
 3922|      0|    const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
 3923|       |
 3924|      0|    mrb_debug_info_append_file(s->mrb, s->irep->debug_info,
 3925|      0|                               filename, s->lines, s->debug_start_pos, s->pc);
 3926|      0|  }
 3927|  3.26k|  mrb_free(s->mrb, s->lines);
 3928|       |
 3929|  3.26k|  irep->nlocals = s->nlocals;
 3930|  3.26k|  irep->nregs = s->nregs;
 3931|       |
 3932|  3.26k|  mrb_gc_arena_restore(mrb, s->ai);
  ------------------
  |  | 1307|  3.26k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 3933|  3.26k|  mrb_pool_close(s->mpool);
 3934|  3.26k|}
codegen.c:true_always:
 2215|  31.9k|{
 2216|  31.9k|  switch (nint(tree->car)) {
  ------------------
  |  | 1227|  31.9k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 2217|      0|  case NODE_TRUE:
  ------------------
  |  Branch (2217:3): [True: 0, False: 31.9k]
  ------------------
 2218|  13.0k|  case NODE_INT:
  ------------------
  |  Branch (2218:3): [True: 13.0k, False: 18.8k]
  ------------------
 2219|  13.0k|  case NODE_STR:
  ------------------
  |  Branch (2219:3): [True: 0, False: 31.9k]
  ------------------
 2220|  13.0k|  case NODE_SYM:
  ------------------
  |  Branch (2220:3): [True: 0, False: 31.9k]
  ------------------
 2221|  13.0k|    return TRUE;
  ------------------
  |  |   54|  13.0k|#  define TRUE 1
  ------------------
 2222|  18.8k|  default:
  ------------------
  |  Branch (2222:3): [True: 18.8k, False: 13.0k]
  ------------------
 2223|  18.8k|    return FALSE;
  ------------------
  |  |   51|  18.8k|#  define FALSE 0
  ------------------
 2224|  31.9k|  }
 2225|  31.9k|}
codegen.c:false_always:
 2229|  18.8k|{
 2230|  18.8k|  switch (nint(tree->car)) {
  ------------------
  |  | 1227|  18.8k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 2231|      0|  case NODE_FALSE:
  ------------------
  |  Branch (2231:3): [True: 0, False: 18.8k]
  ------------------
 2232|      0|  case NODE_NIL:
  ------------------
  |  Branch (2232:3): [True: 0, False: 18.8k]
  ------------------
 2233|      0|    return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 2234|  18.8k|  default:
  ------------------
  |  Branch (2234:3): [True: 18.8k, False: 0]
  ------------------
 2235|  18.8k|    return FALSE;
  ------------------
  |  |   51|  18.8k|#  define FALSE 0
  ------------------
 2236|  18.8k|  }
 2237|  18.8k|}
codegen.c:scope_body:
 1521|  1.73k|{
 1522|  1.73k|  codegen_scope *scope = scope_new(s->mrb, s, tree->car);
 1523|       |
 1524|  1.73k|  codegen(scope, tree->cdr, VAL);
  ------------------
  |  |  326|  1.73k|#define VAL    1
  ------------------
 1525|  1.73k|  gen_return(scope, OP_RETURN, scope->sp-1);
 1526|  1.73k|  if (!s->iseq) {
  ------------------
  |  Branch (1526:7): [True: 1.54k, False: 189]
  ------------------
 1527|  1.54k|    genop_0(scope, OP_STOP);
 1528|  1.54k|  }
 1529|  1.73k|  scope_finish(scope);
 1530|  1.73k|  if (!s->irep) {
  ------------------
  |  Branch (1530:7): [True: 0, False: 1.73k]
  ------------------
 1531|       |    /* should not happen */
 1532|      0|    return 0;
 1533|      0|  }
 1534|  1.73k|  return s->irep->rlen - 1;
 1535|  1.73k|}
codegen.c:gen_call:
 1717|   220k|{
 1718|   220k|  mrb_sym sym = nsym(tree->cdr->car);
  ------------------
  |  | 1229|   220k|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1719|   220k|  int skip = 0, n = 0, nk = 0, noop = no_optimize(s), noself = 0, blk = 0, sp_save = cursp();
  ------------------
  |  |  990|   220k|#define cursp() (s->sp)
  ------------------
 1720|       |
 1721|   220k|  if (!tree->car) {
  ------------------
  |  Branch (1721:7): [True: 1.54k, False: 219k]
  ------------------
 1722|  1.54k|    noself = noop = 1;
 1723|  1.54k|    push();
  ------------------
  |  |  986|  1.54k|#define push() push_n_(s,1)
  ------------------
 1724|  1.54k|  }
 1725|   219k|  else {
 1726|   219k|    codegen(s, tree->car, VAL); /* receiver */
  ------------------
  |  |  326|   219k|#define VAL    1
  ------------------
 1727|   219k|  }
 1728|   220k|  if (safe) {
  ------------------
  |  Branch (1728:7): [True: 0, False: 220k]
  ------------------
 1729|      0|    int recv = cursp()-1;
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1730|      0|    gen_move(s, cursp(), recv, 1);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1731|      0|    skip = genjmp2_0(s, OP_JMPNIL, cursp(), val);
  ------------------
  |  |  583|      0|#define genjmp2_0(s,i,a,val) genjmp2(s,i,a,JMPLINK_START,val)
  |  |  ------------------
  |  |  |  |  494|      0|#define JMPLINK_START UINT32_MAX
  |  |  ------------------
  ------------------
 1732|      0|  }
 1733|   220k|  tree = tree->cdr->cdr->car;
 1734|   220k|  if (tree) {
  ------------------
  |  Branch (1734:7): [True: 202k, False: 18.4k]
  ------------------
 1735|   202k|    if (tree->car) {            /* positional arguments */
  ------------------
  |  Branch (1735:9): [True: 202k, False: 0]
  ------------------
 1736|   202k|      n = gen_values(s, tree->car, VAL, 14);
  ------------------
  |  |  326|   202k|#define VAL    1
  ------------------
 1737|   202k|      if (n < 0) {              /* variable length */
  ------------------
  |  Branch (1737:11): [True: 0, False: 202k]
  ------------------
 1738|      0|        noop = 1;               /* not operator */
 1739|      0|        n = 15;
 1740|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1741|      0|      }
 1742|   202k|    }
 1743|   202k|    if (tree->cdr->car) {       /* keyword arguments */
  ------------------
  |  Branch (1743:9): [True: 0, False: 202k]
  ------------------
 1744|      0|      noop = 1;
 1745|      0|      nk = gen_hash(s, tree->cdr->car->cdr, VAL, 14);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1746|      0|      if (nk < 0) nk = 15;
  ------------------
  |  Branch (1746:11): [True: 0, False: 0]
  ------------------
 1747|      0|    }
 1748|   202k|  }
 1749|   220k|  if (tree && tree->cdr && tree->cdr->cdr) {
  ------------------
  |  Branch (1749:7): [True: 202k, False: 18.4k]
  |  Branch (1749:15): [True: 202k, False: 0]
  |  Branch (1749:28): [True: 0, False: 202k]
  ------------------
 1750|      0|    codegen(s, tree->cdr->cdr, VAL);
  ------------------
  |  |  326|      0|#define VAL    1
  ------------------
 1751|      0|    pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1752|      0|    noop = 1;
 1753|      0|    blk = 1;
 1754|      0|  }
 1755|   220k|  push();pop();
  ------------------
  |  |  986|   220k|#define push() push_n_(s,1)
  ------------------
                push();pop();
  ------------------
  |  |  988|   220k|#define pop() pop_n_(s,1)
  ------------------
 1756|   220k|  s->sp = sp_save;
 1757|   220k|  if (!noop && sym == MRB_OPSYM_2(s->mrb, add) && n == 1)  {
  ------------------
  |  |   20|   219k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1757:7): [True: 219k, False: 1.54k]
  |  Branch (1757:16): [True: 19.6k, False: 199k]
  |  Branch (1757:51): [True: 19.6k, False: 0]
  ------------------
 1758|  19.6k|    gen_addsub(s, OP_ADD, cursp());
  ------------------
  |  |  990|  19.6k|#define cursp() (s->sp)
  ------------------
 1759|  19.6k|  }
 1760|   201k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, sub) && n == 1)  {
  ------------------
  |  |   20|   199k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1760:12): [True: 199k, False: 1.54k]
  |  Branch (1760:21): [True: 21.8k, False: 177k]
  |  Branch (1760:56): [True: 21.8k, False: 0]
  ------------------
 1761|  21.8k|    gen_addsub(s, OP_SUB, cursp());
  ------------------
  |  |  990|  21.8k|#define cursp() (s->sp)
  ------------------
 1762|  21.8k|  }
 1763|   179k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, mul) && n == 1)  {
  ------------------
  |  |   20|   177k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1763:12): [True: 177k, False: 1.54k]
  |  Branch (1763:21): [True: 18.2k, False: 159k]
  |  Branch (1763:56): [True: 18.2k, False: 0]
  ------------------
 1764|  18.2k|    gen_muldiv(s, OP_MUL, cursp());
  ------------------
  |  |  990|  18.2k|#define cursp() (s->sp)
  ------------------
 1765|  18.2k|  }
 1766|   161k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, div) && n == 1)  {
  ------------------
  |  |   20|   159k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1766:12): [True: 159k, False: 1.54k]
  |  Branch (1766:21): [True: 12.7k, False: 146k]
  |  Branch (1766:56): [True: 12.7k, False: 0]
  ------------------
 1767|  12.7k|    gen_muldiv(s, OP_DIV, cursp());
  ------------------
  |  |  990|  12.7k|#define cursp() (s->sp)
  ------------------
 1768|  12.7k|  }
 1769|   148k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, lt) && n == 1)  {
  ------------------
  |  |   20|   146k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1769:12): [True: 146k, False: 1.54k]
  |  Branch (1769:21): [True: 1.41k, False: 145k]
  |  Branch (1769:55): [True: 1.41k, False: 0]
  ------------------
 1770|  1.41k|    genop_1(s, OP_LT, cursp());
  ------------------
  |  |  990|  1.41k|#define cursp() (s->sp)
  ------------------
 1771|  1.41k|  }
 1772|   146k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, le) && n == 1)  {
  ------------------
  |  |   20|   145k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1772:12): [True: 145k, False: 1.54k]
  |  Branch (1772:21): [True: 4.11k, False: 141k]
  |  Branch (1772:55): [True: 4.11k, False: 0]
  ------------------
 1773|  4.11k|    genop_1(s, OP_LE, cursp());
  ------------------
  |  |  990|  4.11k|#define cursp() (s->sp)
  ------------------
 1774|  4.11k|  }
 1775|   142k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, gt) && n == 1)  {
  ------------------
  |  |   20|   141k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1775:12): [True: 141k, False: 1.54k]
  |  Branch (1775:21): [True: 1.51k, False: 139k]
  |  Branch (1775:55): [True: 1.51k, False: 0]
  ------------------
 1776|  1.51k|    genop_1(s, OP_GT, cursp());
  ------------------
  |  |  990|  1.51k|#define cursp() (s->sp)
  ------------------
 1777|  1.51k|  }
 1778|   141k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, ge) && n == 1)  {
  ------------------
  |  |   20|   139k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1778:12): [True: 139k, False: 1.54k]
  |  Branch (1778:21): [True: 1.91k, False: 137k]
  |  Branch (1778:55): [True: 1.91k, False: 0]
  ------------------
 1779|  1.91k|    genop_1(s, OP_GE, cursp());
  ------------------
  |  |  990|  1.91k|#define cursp() (s->sp)
  ------------------
 1780|  1.91k|  }
 1781|   139k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, eq) && n == 1)  {
  ------------------
  |  |   20|   137k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1781:12): [True: 137k, False: 1.54k]
  |  Branch (1781:21): [True: 2.45k, False: 135k]
  |  Branch (1781:55): [True: 2.45k, False: 0]
  ------------------
 1782|  2.45k|    genop_1(s, OP_EQ, cursp());
  ------------------
  |  |  990|  2.45k|#define cursp() (s->sp)
  ------------------
 1783|  2.45k|  }
 1784|   136k|  else if (!noop && sym == MRB_OPSYM_2(s->mrb, aset) && n == 2)  {
  ------------------
  |  |   20|   135k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1784:12): [True: 135k, False: 1.54k]
  |  Branch (1784:21): [True: 0, False: 135k]
  |  Branch (1784:57): [True: 0, False: 0]
  ------------------
 1785|      0|    genop_1(s, OP_SETIDX, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1786|      0|  }
 1787|   136k|  else if (!noop && n == 0 && gen_uniop(s, sym, cursp())) {
  ------------------
  |  |  990|  16.8k|#define cursp() (s->sp)
  ------------------
  |  Branch (1787:12): [True: 135k, False: 1.54k]
  |  Branch (1787:21): [True: 16.8k, False: 118k]
  |  Branch (1787:31): [True: 0, False: 16.8k]
  ------------------
 1788|       |    /* constant folding succeeded */
 1789|      0|  }
 1790|   136k|  else if (!noop && n == 1 && gen_binop(s, sym, cursp())) {
  ------------------
  |  |  990|   118k|#define cursp() (s->sp)
  ------------------
  |  Branch (1790:12): [True: 135k, False: 1.54k]
  |  Branch (1790:21): [True: 118k, False: 16.8k]
  |  Branch (1790:31): [True: 8.96k, False: 109k]
  ------------------
 1791|       |    /* constant folding succeeded */
 1792|  8.96k|  }
 1793|   127k|  else if (noself){
  ------------------
  |  Branch (1793:12): [True: 1.54k, False: 126k]
  ------------------
 1794|  1.54k|    genop_3(s, blk ? OP_SSENDB : OP_SSEND, cursp(), new_sym(s, sym), n|(nk<<4));
  ------------------
  |  |  990|  1.54k|#define cursp() (s->sp)
  ------------------
  |  Branch (1794:16): [True: 0, False: 1.54k]
  ------------------
 1795|  1.54k|  }
 1796|   126k|  else {
 1797|   126k|    genop_3(s, blk ? OP_SENDB : OP_SEND, cursp(), new_sym(s, sym), n|(nk<<4));
  ------------------
  |  |  990|   126k|#define cursp() (s->sp)
  ------------------
  |  Branch (1797:16): [True: 0, False: 126k]
  ------------------
 1798|   126k|  }
 1799|   220k|  if (safe) {
  ------------------
  |  Branch (1799:7): [True: 0, False: 220k]
  ------------------
 1800|      0|    dispatch(s, skip);
 1801|      0|  }
 1802|   220k|  if (val) {
  ------------------
  |  Branch (1802:7): [True: 129k, False: 91.7k]
  ------------------
 1803|   129k|    push();
  ------------------
  |  |  986|   129k|#define push() push_n_(s,1)
  ------------------
 1804|   129k|  }
 1805|   220k|}
codegen.c:gen_muldiv:
  847|  31.0k|{
  848|  31.0k|  if (no_peephole(s)) {
  ------------------
  |  Branch (848:7): [True: 752, False: 30.2k]
  ------------------
  849|  20.4k|  normal:
  850|  20.4k|    genop_1(s, op, dst);
  851|  20.4k|    return;
  852|    752|  }
  853|  30.2k|  else {
  854|  30.2k|    struct mrb_insn_data data = mrb_last_insn(s);
  855|  30.2k|    mrb_int n, n0;
  856|  30.2k|    if (addr_pc(s, data.addr) == s->lastlabel || !get_int_operand(s, &data, &n)) {
  ------------------
  |  |  475|  30.2k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  |  Branch (856:9): [True: 1.23k, False: 29.0k]
  |  Branch (856:50): [True: 13.4k, False: 15.6k]
  ------------------
  857|       |      /* not integer immediate */
  858|  14.6k|      goto normal;
  859|  14.6k|    }
  860|  15.6k|    struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr));
  861|  15.6k|    if (!get_int_operand(s, &data0, &n0)) {
  ------------------
  |  Branch (861:9): [True: 5.04k, False: 10.5k]
  ------------------
  862|  5.04k|      goto normal;
  863|  5.04k|    }
  864|  10.5k|    if (op == OP_MUL) {
  ------------------
  |  Branch (864:9): [True: 6.58k, False: 4.00k]
  ------------------
  865|  6.58k|      if (mrb_int_mul_overflow(n0, n, &n)) goto normal;
  ------------------
  |  Branch (865:11): [True: 13, False: 6.57k]
  ------------------
  866|  6.58k|    }
  867|  4.00k|    else { /* OP_DIV */
  868|  4.00k|      if (n == 0) goto normal;
  ------------------
  |  Branch (868:11): [True: 10, False: 3.99k]
  ------------------
  869|  3.99k|      if (n0 == MRB_INT_MIN && n == -1) goto normal;
  ------------------
  |  |   81|  7.98k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (869:11): [True: 290, False: 3.70k]
  |  Branch (869:32): [True: 11, False: 279]
  ------------------
  870|  3.98k|      n = mrb_div_int(n0, n);
  871|  3.98k|    }
  872|  10.5k|    s->pc = addr_pc(s, data0.addr);
  ------------------
  |  |  475|  10.5k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  873|  10.5k|    gen_int(s, dst, n);
  874|  10.5k|  }
  875|  31.0k|}
codegen.c:gen_binop:
  881|   118k|{
  882|   118k|  if (no_peephole(s)) return FALSE;
  ------------------
  |  |   51|    320|#  define FALSE 0
  ------------------
  |  Branch (882:7): [True: 320, False: 118k]
  ------------------
  883|   118k|  else if (op == MRB_OPSYM_2(s->mrb, aref)) {
  ------------------
  |  |   20|   118k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (883:12): [True: 0, False: 118k]
  ------------------
  884|      0|    genop_1(s, OP_GETIDX, dst);
  885|      0|    return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  886|      0|  }
  887|   118k|  else {
  888|   118k|    struct mrb_insn_data data = mrb_last_insn(s);
  889|   118k|    mrb_int n, n0;
  890|   118k|    if (addr_pc(s, data.addr) == s->lastlabel || !get_int_operand(s, &data, &n)) {
  ------------------
  |  |  475|   118k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  |  Branch (890:9): [True: 234, False: 117k]
  |  Branch (890:50): [True: 31.8k, False: 86.1k]
  ------------------
  891|       |      /* not integer immediate */
  892|  32.0k|      return FALSE;
  ------------------
  |  |   51|  32.0k|#  define FALSE 0
  ------------------
  893|  32.0k|    }
  894|  86.1k|    struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr));
  895|  86.1k|    if (!get_int_operand(s, &data0, &n0)) {
  ------------------
  |  Branch (895:9): [True: 74.9k, False: 11.1k]
  ------------------
  896|  74.9k|      return FALSE;
  ------------------
  |  |   51|  74.9k|#  define FALSE 0
  ------------------
  897|  74.9k|    }
  898|  11.1k|    if (op == MRB_OPSYM_2(s->mrb, lshift)) {
  ------------------
  |  |   20|  11.1k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (898:9): [True: 0, False: 11.1k]
  ------------------
  899|      0|      if (!mrb_num_shift(s->mrb, n0, n, &n)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (899:11): [True: 0, False: 0]
  ------------------
  900|      0|    }
  901|  11.1k|    else if (op == MRB_OPSYM_2(s->mrb, rshift)) {
  ------------------
  |  |   20|  11.1k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (901:14): [True: 5.09k, False: 6.06k]
  ------------------
  902|  5.09k|      if (n == MRB_INT_MIN) return FALSE;
  ------------------
  |  |   81|  5.09k|# define MRB_INT_MIN INT64_MIN
  ------------------
                    if (n == MRB_INT_MIN) return FALSE;
  ------------------
  |  |   51|     39|#  define FALSE 0
  ------------------
  |  Branch (902:11): [True: 39, False: 5.05k]
  ------------------
  903|  5.05k|      if (!mrb_num_shift(s->mrb, n0, -n, &n)) return FALSE;
  ------------------
  |  |   51|    725|#  define FALSE 0
  ------------------
  |  Branch (903:11): [True: 725, False: 4.33k]
  ------------------
  904|  5.05k|    }
  905|  6.06k|    else if (op == MRB_OPSYM_2(s->mrb, mod) && n != 0) {
  ------------------
  |  |   20|  6.06k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (905:14): [True: 1.74k, False: 4.31k]
  |  Branch (905:48): [True: 1.70k, False: 39]
  ------------------
  906|  1.70k|      if (n0 == MRB_INT_MIN && n == -1) {
  ------------------
  |  |   81|  3.40k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (906:11): [True: 124, False: 1.57k]
  |  Branch (906:32): [True: 74, False: 50]
  ------------------
  907|     74|        n = 0;
  908|     74|      }
  909|  1.62k|      else {
  910|  1.62k|        mrb_int n1 = n0 % n;
  911|  1.62k|        if ((n0 < 0) != (n < 0) && n1 != 0) {
  ------------------
  |  Branch (911:13): [True: 691, False: 937]
  |  Branch (911:36): [True: 586, False: 105]
  ------------------
  912|    586|          n1 += n;
  913|    586|        }
  914|  1.62k|        n = n1;
  915|  1.62k|      }
  916|  1.70k|    }
  917|  4.35k|    else if (op == MRB_OPSYM_2(s->mrb, and)) {
  ------------------
  |  |   20|  4.35k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (917:14): [True: 0, False: 4.35k]
  ------------------
  918|      0|      n = n0 & n;
  919|      0|    }
  920|  4.35k|    else if (op == MRB_OPSYM_2(s->mrb, or)) {
  ------------------
  |  |   20|  4.35k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (920:14): [True: 0, False: 4.35k]
  ------------------
  921|      0|      n = n0 | n;
  922|      0|    }
  923|  4.35k|    else if (op == MRB_OPSYM_2(s->mrb, xor)) {
  ------------------
  |  |   20|  4.35k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (923:14): [True: 2.93k, False: 1.42k]
  ------------------
  924|  2.93k|      n = n0 ^ n;
  925|  2.93k|    }
  926|  1.42k|    else {
  927|  1.42k|      return FALSE;
  ------------------
  |  |   51|  1.42k|#  define FALSE 0
  ------------------
  928|  1.42k|    }
  929|  8.96k|    s->pc = addr_pc(s, data0.addr);
  ------------------
  |  |  475|  8.96k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  930|  8.96k|    gen_int(s, dst, n);
  931|  8.96k|    return TRUE;
  ------------------
  |  |   54|  8.96k|#  define TRUE 1
  ------------------
  932|  11.1k|  }
  933|   118k|}
codegen.c:gen_values:
 1574|   258k|{
 1575|   258k|  int n = 0;
 1576|   258k|  int first = 1;
 1577|   258k|  int slimit = GEN_VAL_STACK_MAX;
  ------------------
  |  | 1570|   258k|#define GEN_VAL_STACK_MAX 99
  ------------------
 1578|       |
 1579|   258k|  if (limit == 0) limit = GEN_LIT_ARY_MAX;
  ------------------
  |  | 1569|  55.7k|#define GEN_LIT_ARY_MAX 64
  ------------------
  |  Branch (1579:7): [True: 55.7k, False: 202k]
  ------------------
 1580|   258k|  if (cursp() >= slimit) slimit = INT16_MAX;
  ------------------
  |  |  990|   258k|#define cursp() (s->sp)
  ------------------
  |  Branch (1580:7): [True: 43.4k, False: 214k]
  ------------------
 1581|       |
 1582|   258k|  if (!val) {
  ------------------
  |  Branch (1582:7): [True: 0, False: 258k]
  ------------------
 1583|      0|    while (t) {
  ------------------
  |  Branch (1583:12): [True: 0, False: 0]
  ------------------
 1584|      0|      codegen(s, t->car, NOVAL);
  ------------------
  |  |  325|      0|#define NOVAL  0
  ------------------
 1585|      0|      n++;
 1586|      0|      t = t->cdr;
 1587|      0|    }
 1588|      0|    return n;
 1589|      0|  }
 1590|       |
 1591|   755k|  while (t) {
  ------------------
  |  Branch (1591:10): [True: 497k, False: 258k]
  ------------------
 1592|   497k|    int is_splat = nint(t->car->car) == NODE_SPLAT;
  ------------------
  |  | 1227|   497k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
 1593|       |
 1594|   497k|    if (is_splat || cursp() >= slimit) { /* flush stack */
  ------------------
  |  |  990|   497k|#define cursp() (s->sp)
  ------------------
  |  Branch (1594:9): [True: 0, False: 497k]
  |  Branch (1594:21): [True: 1.80k, False: 495k]
  ------------------
 1595|  1.80k|      pop_n(n);
  ------------------
  |  |  989|  1.80k|#define pop_n(n) pop_n_(s,n)
  ------------------
 1596|  1.80k|      if (first) {
  ------------------
  |  Branch (1596:11): [True: 331, False: 1.47k]
  ------------------
 1597|    331|        if (n == 0) {
  ------------------
  |  Branch (1597:13): [True: 0, False: 331]
  ------------------
 1598|      0|          genop_1(s, OP_LOADNIL, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1599|      0|        }
 1600|    331|        else {
 1601|    331|          genop_2(s, OP_ARRAY, cursp(), n);
  ------------------
  |  |  990|    331|#define cursp() (s->sp)
  ------------------
 1602|    331|        }
 1603|    331|        push();
  ------------------
  |  |  986|    331|#define push() push_n_(s,1)
  ------------------
 1604|    331|        first = 0;
 1605|    331|        limit = GEN_LIT_ARY_MAX;
  ------------------
  |  | 1569|    331|#define GEN_LIT_ARY_MAX 64
  ------------------
 1606|    331|      }
 1607|  1.47k|      else if (n > 0) {
  ------------------
  |  Branch (1607:16): [True: 1.47k, False: 0]
  ------------------
 1608|  1.47k|        pop();
  ------------------
  |  |  988|  1.47k|#define pop() pop_n_(s,1)
  ------------------
 1609|  1.47k|        genop_2(s, OP_ARYPUSH, cursp(), n);
  ------------------
  |  |  990|  1.47k|#define cursp() (s->sp)
  ------------------
 1610|  1.47k|        push();
  ------------------
  |  |  986|  1.47k|#define push() push_n_(s,1)
  ------------------
 1611|  1.47k|      }
 1612|  1.80k|      n = 0;
 1613|  1.80k|    }
 1614|   497k|    codegen(s, t->car, val);
 1615|   497k|    if (is_splat) {
  ------------------
  |  Branch (1615:9): [True: 0, False: 497k]
  ------------------
 1616|      0|      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                    pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1617|      0|      genop_1(s, OP_ARYCAT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1618|      0|      push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1619|      0|    }
 1620|   497k|    else {
 1621|   497k|      n++;
 1622|   497k|    }
 1623|   497k|    t = t->cdr;
 1624|   497k|  }
 1625|   258k|  if (!first) {
  ------------------
  |  Branch (1625:7): [True: 331, False: 257k]
  ------------------
 1626|    331|    pop();
  ------------------
  |  |  988|    331|#define pop() pop_n_(s,1)
  ------------------
 1627|    331|    if (n > 0) {
  ------------------
  |  Branch (1627:9): [True: 331, False: 0]
  ------------------
 1628|    331|      pop_n(n);
  ------------------
  |  |  989|    331|#define pop_n(n) pop_n_(s,n)
  ------------------
 1629|    331|      genop_2(s, OP_ARYPUSH, cursp(), n);
  ------------------
  |  |  990|    331|#define cursp() (s->sp)
  ------------------
 1630|    331|    }
 1631|    331|    return -1;                  /* variable length */
 1632|    331|  }
 1633|   257k|  else if (n > limit) {
  ------------------
  |  Branch (1633:12): [True: 184, False: 257k]
  ------------------
 1634|    184|    pop_n(n);
  ------------------
  |  |  989|    184|#define pop_n(n) pop_n_(s,n)
  ------------------
 1635|    184|    genop_2(s, OP_ARRAY, cursp(), n);
  ------------------
  |  |  990|    184|#define cursp() (s->sp)
  ------------------
 1636|    184|    return -1;
 1637|    184|  }
 1638|   257k|  return n;
 1639|   258k|}
codegen.c:gen_hash:
 1643|  3.58k|{
 1644|  3.58k|  int slimit = GEN_VAL_STACK_MAX;
  ------------------
  |  | 1570|  3.58k|#define GEN_VAL_STACK_MAX 99
  ------------------
 1645|  3.58k|  if (cursp() >= GEN_LIT_ARY_MAX) slimit = INT16_MAX;
  ------------------
  |  |  990|  3.58k|#define cursp() (s->sp)
  ------------------
                if (cursp() >= GEN_LIT_ARY_MAX) slimit = INT16_MAX;
  ------------------
  |  | 1569|  3.58k|#define GEN_LIT_ARY_MAX 64
  ------------------
  |  Branch (1645:7): [True: 1.91k, False: 1.67k]
  ------------------
 1646|  3.58k|  int len = 0;
 1647|  3.58k|  mrb_bool update = FALSE;
  ------------------
  |  |   51|  3.58k|#  define FALSE 0
  ------------------
 1648|  3.58k|  mrb_bool first = TRUE;
  ------------------
  |  |   54|  3.58k|#  define TRUE 1
  ------------------
 1649|       |
 1650|   132k|  while (tree) {
  ------------------
  |  Branch (1650:10): [True: 129k, False: 3.58k]
  ------------------
 1651|   129k|    if (nint(tree->car->car->car) == NODE_KW_REST_ARGS) {
  ------------------
  |  | 1227|   129k|#define nint(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (1651:9): [True: 0, False: 129k]
  ------------------
 1652|      0|      if (val && first) {
  ------------------
  |  Branch (1652:11): [True: 0, False: 0]
  |  Branch (1652:18): [True: 0, False: 0]
  ------------------
 1653|      0|        genop_2(s, OP_HASH, cursp(), 0);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1654|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1655|      0|        update = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 1656|      0|      }
 1657|      0|      else if (val && len > 0) {
  ------------------
  |  Branch (1657:16): [True: 0, False: 0]
  |  Branch (1657:23): [True: 0, False: 0]
  ------------------
 1658|      0|        pop_n(len*2);
  ------------------
  |  |  989|      0|#define pop_n(n) pop_n_(s,n)
  ------------------
 1659|      0|        if (!update) {
  ------------------
  |  Branch (1659:13): [True: 0, False: 0]
  ------------------
 1660|      0|          genop_2(s, OP_HASH, cursp(), len);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1661|      0|        }
 1662|      0|        else {
 1663|      0|          pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1664|      0|          genop_2(s, OP_HASHADD, cursp(), len);
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1665|      0|        }
 1666|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1667|      0|      }
 1668|      0|      codegen(s, tree->car->cdr, val);
 1669|      0|      if (val && (len > 0 || update)) {
  ------------------
  |  Branch (1669:11): [True: 0, False: 0]
  |  Branch (1669:19): [True: 0, False: 0]
  |  Branch (1669:30): [True: 0, False: 0]
  ------------------
 1670|      0|        pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
                      pop(); pop();
  ------------------
  |  |  988|      0|#define pop() pop_n_(s,1)
  ------------------
 1671|      0|        genop_1(s, OP_HASHCAT, cursp());
  ------------------
  |  |  990|      0|#define cursp() (s->sp)
  ------------------
 1672|      0|        push();
  ------------------
  |  |  986|      0|#define push() push_n_(s,1)
  ------------------
 1673|      0|      }
 1674|      0|      update = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 1675|      0|      len = 0;
 1676|      0|    }
 1677|   129k|    else {
 1678|   129k|      codegen(s, tree->car->car, val);
 1679|   129k|      codegen(s, tree->car->cdr, val);
 1680|   129k|      len++;
 1681|   129k|    }
 1682|   129k|    tree = tree->cdr;
 1683|   129k|    if (val && cursp() >= slimit) {
  ------------------
  |  |  990|   129k|#define cursp() (s->sp)
  ------------------
  |  Branch (1683:9): [True: 129k, False: 0]
  |  Branch (1683:16): [True: 1.21k, False: 128k]
  ------------------
 1684|  1.21k|      pop_n(len*2);
  ------------------
  |  |  989|  1.21k|#define pop_n(n) pop_n_(s,n)
  ------------------
 1685|  1.21k|      if (!update) {
  ------------------
  |  Branch (1685:11): [True: 347, False: 865]
  ------------------
 1686|    347|        genop_2(s, OP_HASH, cursp(), len);
  ------------------
  |  |  990|    347|#define cursp() (s->sp)
  ------------------
 1687|    347|      }
 1688|    865|      else {
 1689|    865|        pop();
  ------------------
  |  |  988|    865|#define pop() pop_n_(s,1)
  ------------------
 1690|    865|        genop_2(s, OP_HASHADD, cursp(), len);
  ------------------
  |  |  990|    865|#define cursp() (s->sp)
  ------------------
 1691|    865|      }
 1692|  1.21k|      push();
  ------------------
  |  |  986|  1.21k|#define push() push_n_(s,1)
  ------------------
 1693|  1.21k|      update = TRUE;
  ------------------
  |  |   54|  1.21k|#  define TRUE 1
  ------------------
 1694|  1.21k|      len = 0;
 1695|  1.21k|    }
 1696|   129k|    first = FALSE;
  ------------------
  |  |   51|   129k|#  define FALSE 0
  ------------------
 1697|   129k|  }
 1698|  3.58k|  if (val && len > limit) {
  ------------------
  |  Branch (1698:7): [True: 3.58k, False: 0]
  |  Branch (1698:14): [True: 200, False: 3.38k]
  ------------------
 1699|    200|    pop_n(len*2);
  ------------------
  |  |  989|    200|#define pop_n(n) pop_n_(s,n)
  ------------------
 1700|    200|    genop_2(s, OP_HASH, cursp(), len);
  ------------------
  |  |  990|    200|#define cursp() (s->sp)
  ------------------
 1701|    200|    push();
  ------------------
  |  |  986|    200|#define push() push_n_(s,1)
  ------------------
 1702|    200|    return -1;
 1703|    200|  }
 1704|  3.38k|  if (update) {
  ------------------
  |  Branch (1704:7): [True: 347, False: 3.03k]
  ------------------
 1705|    347|    if (val && len > 0) {
  ------------------
  |  Branch (1705:9): [True: 347, False: 0]
  |  Branch (1705:16): [True: 253, False: 94]
  ------------------
 1706|    253|      pop_n(len*2+1);
  ------------------
  |  |  989|    253|#define pop_n(n) pop_n_(s,n)
  ------------------
 1707|    253|      genop_2(s, OP_HASHADD, cursp(), len);
  ------------------
  |  |  990|    253|#define cursp() (s->sp)
  ------------------
 1708|    253|      push();
  ------------------
  |  |  986|    253|#define push() push_n_(s,1)
  ------------------
 1709|    253|    }
 1710|    347|    return -1;                  /* variable length */
 1711|    347|  }
 1712|  3.03k|  return len;
 1713|  3.38k|}
codegen.c:gen_addsub:
  802|  41.5k|{
  803|  41.5k|  if (no_peephole(s)) {
  ------------------
  |  Branch (803:7): [True: 423, False: 41.1k]
  ------------------
  804|  19.8k|  normal:
  805|  19.8k|    genop_1(s, op, dst);
  806|  19.8k|    return;
  807|    423|  }
  808|  41.1k|  else {
  809|  41.1k|    struct mrb_insn_data data = mrb_last_insn(s);
  810|  41.1k|    mrb_int n;
  811|       |
  812|  41.1k|    if (!get_int_operand(s, &data, &n)) {
  ------------------
  |  Branch (812:9): [True: 18.9k, False: 22.1k]
  ------------------
  813|       |      /* not integer immediate */
  814|  18.9k|      goto normal;
  815|  18.9k|    }
  816|  22.1k|    struct mrb_insn_data data0 = mrb_decode_insn(mrb_prev_pc(s, data.addr));
  817|  22.1k|    mrb_int n0;
  818|  22.1k|    if (addr_pc(s, data.addr) == s->lastlabel || !get_int_operand(s, &data0, &n0)) {
  ------------------
  |  |  475|  22.1k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  |  Branch (818:9): [True: 501, False: 21.6k]
  |  Branch (818:50): [True: 8.42k, False: 13.1k]
  ------------------
  819|       |      /* OP_ADDI/OP_SUBI takes upto 8bits */
  820|  8.92k|      if (n > INT8_MAX || n < INT8_MIN) goto normal;
  ------------------
  |  Branch (820:11): [True: 270, False: 8.65k]
  |  Branch (820:27): [True: 75, False: 8.57k]
  ------------------
  821|  8.57k|      rewind_pc(s);
  ------------------
  |  |  476|  8.57k|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  822|  8.57k|      if (n == 0) return;
  ------------------
  |  Branch (822:11): [True: 463, False: 8.11k]
  ------------------
  823|  8.11k|      if (n > 0) {
  ------------------
  |  Branch (823:11): [True: 7.81k, False: 304]
  ------------------
  824|  7.81k|        if (op == OP_ADD) genop_2(s, OP_ADDI, dst, (uint16_t)n);
  ------------------
  |  Branch (824:13): [True: 4.70k, False: 3.11k]
  ------------------
  825|  3.11k|        else genop_2(s, OP_SUBI, dst, (uint16_t)n);
  826|  7.81k|      }
  827|    304|      else {                    /* n < 0 */
  828|    304|        n = -n;
  829|    304|        if (op == OP_ADD) genop_2(s, OP_SUBI, dst, (uint16_t)n);
  ------------------
  |  Branch (829:13): [True: 55, False: 249]
  ------------------
  830|    249|        else genop_2(s, OP_ADDI, dst, (uint16_t)n);
  831|    304|      }
  832|  8.11k|      return;
  833|  8.57k|    }
  834|  13.1k|    if (op == OP_ADD) {
  ------------------
  |  Branch (834:9): [True: 5.32k, False: 7.87k]
  ------------------
  835|  5.32k|      if (mrb_int_add_overflow(n0, n, &n)) goto normal;
  ------------------
  |  Branch (835:11): [True: 24, False: 5.30k]
  ------------------
  836|  5.32k|    }
  837|  7.87k|    else { /* OP_SUB */
  838|  7.87k|      if (mrb_int_sub_overflow(n0, n, &n)) goto normal;
  ------------------
  |  Branch (838:11): [True: 59, False: 7.81k]
  ------------------
  839|  7.87k|    }
  840|  13.1k|    s->pc = addr_pc(s, data0.addr);
  ------------------
  |  |  475|  13.1k|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
  841|  13.1k|    gen_int(s, dst, n);
  842|  13.1k|  }
  843|  41.5k|}
codegen.c:genop_2S:
  298|  2.07k|{
  299|  2.07k|  genop_1(s, i, a);
  300|  2.07k|  gen_S(s, b);
  301|  2.07k|}
codegen.c:gen_return:
  734|  3.26k|{
  735|  3.26k|  if (no_peephole(s)) {
  ------------------
  |  Branch (735:7): [True: 1.72k, False: 1.54k]
  ------------------
  736|  1.72k|    genop_1(s, op, src);
  737|  1.72k|  }
  738|  1.54k|  else {
  739|  1.54k|    struct mrb_insn_data data = mrb_last_insn(s);
  740|       |
  741|  1.54k|    if (data.insn == OP_MOVE && src == data.a) {
  ------------------
  |  Branch (741:9): [True: 0, False: 1.54k]
  |  Branch (741:33): [True: 0, False: 0]
  ------------------
  742|      0|      rewind_pc(s);
  ------------------
  |  |  476|      0|#define rewind_pc(s) s->pc = s->lastpc
  ------------------
  743|      0|      genop_1(s, op, data.b);
  744|      0|    }
  745|  1.54k|    else if (data.insn != OP_RETURN) {
  ------------------
  |  Branch (745:14): [True: 1.54k, False: 0]
  ------------------
  746|  1.54k|      genop_1(s, op, src);
  747|  1.54k|    }
  748|  1.54k|  }
  749|  3.26k|}
codegen.c:lv_idx:
 1235|   284k|{
 1236|   284k|  node *lv = s->lv;
 1237|   284k|  int n = 1;
 1238|       |
 1239|  92.4M|  while (lv) {
  ------------------
  |  Branch (1239:10): [True: 92.4M, False: 0]
  ------------------
 1240|  92.4M|    if (lv_name(lv) == id) return n;
  ------------------
  |  | 1231|  92.4M|#define lv_name(lv) nsym((lv)->car)
  |  |  ------------------
  |  |  |  | 1229|  92.4M|#define nsym(x) ((mrb_sym)(intptr_t)(x))
  |  |  ------------------
  ------------------
  |  Branch (1240:9): [True: 284k, False: 92.1M]
  ------------------
 1241|  92.1M|    n++;
 1242|  92.1M|    lv = lv->cdr;
 1243|  92.1M|  }
 1244|      0|  return 0;
 1245|   284k|}
codegen.c:readint:
 2155|   656k|{
 2156|   656k|  const char *e = p + strlen(p);
 2157|   656k|  mrb_int result = 0;
 2158|       |
 2159|   656k|  mrb_assert(base >= 2 && base <= 16);
  ------------------
  |  |   68|   656k|#define mrb_assert(p) ((void)0)
  ------------------
 2160|   656k|  if (*p == '+') p++;
  ------------------
  |  Branch (2160:7): [True: 0, False: 656k]
  ------------------
 2161|  1.31M|  while (p < e) {
  ------------------
  |  Branch (2161:10): [True: 660k, False: 656k]
  ------------------
 2162|   660k|    int n;
 2163|   660k|    char c = *p;
 2164|   660k|    switch (c) {
 2165|   635k|    case '0': case '1': case '2': case '3':
  ------------------
  |  Branch (2165:5): [True: 11.8k, False: 648k]
  |  Branch (2165:15): [True: 619k, False: 41.4k]
  |  Branch (2165:25): [True: 2.91k, False: 657k]
  |  Branch (2165:35): [True: 1.58k, False: 659k]
  ------------------
 2166|   649k|    case '4': case '5': case '6': case '7':
  ------------------
  |  Branch (2166:5): [True: 2.38k, False: 658k]
  |  Branch (2166:15): [True: 1.86k, False: 658k]
  |  Branch (2166:25): [True: 7.68k, False: 653k]
  |  Branch (2166:35): [True: 1.76k, False: 658k]
  ------------------
 2167|   649k|      n = c - '0'; break;
 2168|  11.4k|    case '8': case '9':
  ------------------
  |  Branch (2168:5): [True: 9.76k, False: 650k]
  |  Branch (2168:15): [True: 1.67k, False: 659k]
  ------------------
 2169|  11.4k|      n = c - '0'; break;
 2170|      0|    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  ------------------
  |  Branch (2170:5): [True: 0, False: 660k]
  |  Branch (2170:15): [True: 0, False: 660k]
  |  Branch (2170:25): [True: 0, False: 660k]
  |  Branch (2170:35): [True: 0, False: 660k]
  |  Branch (2170:45): [True: 0, False: 660k]
  |  Branch (2170:55): [True: 0, False: 660k]
  ------------------
 2171|      0|      n = c - 'a' + 10; break;
 2172|      0|    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  ------------------
  |  Branch (2172:5): [True: 0, False: 660k]
  |  Branch (2172:15): [True: 0, False: 660k]
  |  Branch (2172:25): [True: 0, False: 660k]
  |  Branch (2172:35): [True: 0, False: 660k]
  |  Branch (2172:45): [True: 0, False: 660k]
  |  Branch (2172:55): [True: 0, False: 660k]
  ------------------
 2173|      0|      n = c - 'A' + 10; break;
 2174|      0|    default:
  ------------------
  |  Branch (2174:5): [True: 0, False: 660k]
  ------------------
 2175|      0|      codegen_error(s, "malformed readint input");
 2176|      0|      *overflow = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 2177|       |      /* not reached */
 2178|      0|      return result;
 2179|   660k|    }
 2180|   660k|    if (mrb_int_mul_overflow(result, base, &result)) {
  ------------------
  |  Branch (2180:9): [True: 0, False: 660k]
  ------------------
 2181|      0|    overflow:
 2182|      0|      *overflow = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 2183|      0|      return 0;
 2184|      0|    }
 2185|   660k|    mrb_uint tmp = ((mrb_uint)result)+n;
 2186|   660k|    if (neg && tmp == (mrb_uint)MRB_INT_MAX+1) {
  ------------------
  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  ------------------
  |  Branch (2186:9): [True: 0, False: 660k]
  |  Branch (2186:16): [True: 0, False: 0]
  ------------------
 2187|      0|      *overflow = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2188|      0|      return MRB_INT_MIN;
  ------------------
  |  |   81|      0|# define MRB_INT_MIN INT64_MIN
  ------------------
 2189|      0|    }
 2190|   660k|    if (tmp > MRB_INT_MAX) goto overflow;
  ------------------
  |  |   82|   660k|# define MRB_INT_MAX INT64_MAX
  ------------------
  |  Branch (2190:9): [True: 0, False: 660k]
  ------------------
 2191|   660k|    result = (mrb_int)tmp;
 2192|   660k|    p++;
 2193|   660k|  }
 2194|   656k|  *overflow = FALSE;
  ------------------
  |  |   51|   656k|#  define FALSE 0
  ------------------
 2195|   656k|  if (neg) return -result;
  ------------------
  |  Branch (2195:7): [True: 0, False: 656k]
  ------------------
 2196|   656k|  return result;
 2197|   656k|}
codegen.c:lit_pool_extend:
  994|  19.3k|{
  995|  19.3k|  if (s->irep->plen == s->pcapa) {
  ------------------
  |  Branch (995:7): [True: 284, False: 19.0k]
  ------------------
  996|    284|    s->pcapa *= 2;
  997|    284|    s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa);
  998|    284|  }
  999|       |
 1000|  19.3k|  return &s->pool[s->irep->plen++];
 1001|  19.3k|}
codegen.c:gen_int:
 1171|   689k|{
 1172|   689k|  if (i < 0) {
  ------------------
  |  Branch (1172:7): [True: 10.9k, False: 678k]
  ------------------
 1173|  10.9k|    if (i == -1) genop_1(s, OP_LOADI__1, dst);
  ------------------
  |  Branch (1173:9): [True: 1.37k, False: 9.56k]
  ------------------
 1174|  9.56k|    else if (i >= -0xff) genop_2(s, OP_LOADINEG, dst, (uint16_t)-i);
  ------------------
  |  Branch (1174:14): [True: 6.70k, False: 2.85k]
  ------------------
 1175|  2.85k|    else if (i >= INT16_MIN) genop_2S(s, OP_LOADI16, dst, (uint16_t)i);
  ------------------
  |  Branch (1175:14): [True: 713, False: 2.14k]
  ------------------
 1176|  2.14k|    else if (i >= INT32_MIN) genop_2SS(s, OP_LOADI32, dst, (uint32_t)i);
  ------------------
  |  Branch (1176:14): [True: 348, False: 1.79k]
  ------------------
 1177|  1.79k|    else goto int_lit;
 1178|  10.9k|  }
 1179|   678k|  else if (i < 8) genop_1(s, OP_LOADI_0 + (uint8_t)i, dst);
  ------------------
  |  Branch (1179:12): [True: 655k, False: 23.2k]
  ------------------
 1180|  23.2k|  else if (i <= 0xff) genop_2(s, OP_LOADI, dst, (uint16_t)i);
  ------------------
  |  Branch (1180:12): [True: 19.2k, False: 3.99k]
  ------------------
 1181|  3.99k|  else if (i <= INT16_MAX) genop_2S(s, OP_LOADI16, dst, (uint16_t)i);
  ------------------
  |  Branch (1181:12): [True: 1.16k, False: 2.83k]
  ------------------
 1182|  2.83k|  else if (i <= INT32_MAX) genop_2SS(s, OP_LOADI32, dst, (uint32_t)i);
  ------------------
  |  Branch (1182:12): [True: 1.74k, False: 1.09k]
  ------------------
 1183|  1.09k|  else {
 1184|  2.89k|  int_lit:
 1185|  2.89k|    genop_2(s, OP_LOADL, dst, new_lit_int(s, i));
 1186|  2.89k|  }
 1187|   689k|}
codegen.c:new_lit_int:
 1079|  2.89k|{
 1080|  2.89k|  int i;
 1081|  2.89k|  mrb_pool_value *pv;
 1082|       |
 1083|   166k|  for (i=0; i<s->irep->plen; i++) {
  ------------------
  |  Branch (1083:13): [True: 165k, False: 787]
  ------------------
 1084|   165k|    pv = &s->pool[i];
 1085|   165k|    if (pv->tt == IREP_TT_INT32) {
  ------------------
  |  Branch (1085:9): [True: 0, False: 165k]
  ------------------
 1086|      0|      if (num == pv->u.i32) return i;
  ------------------
  |  Branch (1086:11): [True: 0, False: 0]
  ------------------
 1087|      0|    }
 1088|   165k|#ifdef MRB_64BIT
 1089|   165k|    else if (pv->tt == IREP_TT_INT64) {
  ------------------
  |  Branch (1089:14): [True: 24.7k, False: 141k]
  ------------------
 1090|  24.7k|      if (num == pv->u.i64) return i;
  ------------------
  |  Branch (1090:11): [True: 2.10k, False: 22.5k]
  ------------------
 1091|  24.7k|    }
 1092|   163k|    continue;
 1093|   165k|#endif
 1094|   165k|  }
 1095|       |
 1096|    787|  pv = lit_pool_extend(s);
 1097|       |
 1098|    787|#ifdef MRB_INT64
 1099|    787|  pv->tt = IREP_TT_INT64;
 1100|    787|  pv->u.i64 = num;
 1101|       |#else
 1102|       |  pv->tt = IREP_TT_INT32;
 1103|       |  pv->u.i32 = num;
 1104|       |#endif
 1105|       |
 1106|    787|  return i;
 1107|  2.89k|}
codegen.c:gen_uniop:
 1191|  16.8k|{
 1192|  16.8k|  if (no_peephole(s)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (1192:7): [True: 0, False: 16.8k]
  ------------------
 1193|  16.8k|  struct mrb_insn_data data = mrb_last_insn(s);
 1194|  16.8k|  mrb_int n;
 1195|       |
 1196|  16.8k|  if (!get_int_operand(s, &data, &n)) return FALSE;
  ------------------
  |  |   51|  16.8k|#  define FALSE 0
  ------------------
  |  Branch (1196:7): [True: 16.8k, False: 0]
  ------------------
 1197|      0|  if (sym == MRB_OPSYM_2(s->mrb, plus)) {
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1197:7): [True: 0, False: 0]
  ------------------
 1198|       |    /* unary plus does nothing */
 1199|      0|  }
 1200|      0|  else if (sym == MRB_OPSYM_2(s->mrb, minus)) {
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1200:12): [True: 0, False: 0]
  ------------------
 1201|      0|    if (n == MRB_INT_MIN) return FALSE;
  ------------------
  |  |   81|      0|# define MRB_INT_MIN INT64_MIN
  ------------------
                  if (n == MRB_INT_MIN) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (1201:9): [True: 0, False: 0]
  ------------------
 1202|      0|    n = -n;
 1203|      0|  }
 1204|      0|  else if (sym == MRB_OPSYM_2(s->mrb, neg)) {
  ------------------
  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  ------------------
  |  Branch (1204:12): [True: 0, False: 0]
  ------------------
 1205|      0|    n = ~n;
 1206|      0|  }
 1207|      0|  else {
 1208|      0|    return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 1209|      0|  }
 1210|      0|  s->pc = addr_pc(s, data.addr);
  ------------------
  |  |  475|      0|#define addr_pc(s, addr) (uint32_t)((addr) - s->iseq)
  ------------------
 1211|      0|  gen_int(s, dst, n);
 1212|      0|  return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 1213|      0|}
codegen.c:new_lit_str:
 1040|   258k|{
 1041|   258k|  int i;
 1042|   258k|  mrb_pool_value *pv;
 1043|       |
 1044|  3.07M|  for (i=0; i<s->irep->plen; i++) {
  ------------------
  |  Branch (1044:13): [True: 3.05M, False: 18.5k]
  ------------------
 1045|  3.05M|    pv = &s->pool[i];
 1046|  3.05M|    if (pv->tt & IREP_TT_NFLAG) continue;
  ------------------
  |  |   27|  3.05M|#define IREP_TT_NFLAG 1       /* number (non string) flag */
  ------------------
  |  Branch (1046:9): [True: 1.68k, False: 3.05M]
  ------------------
 1047|  3.05M|    mrb_int plen = pv->tt>>2;
 1048|  3.05M|    if (len != plen) continue;
  ------------------
  |  Branch (1048:9): [True: 2.52M, False: 522k]
  ------------------
 1049|   522k|    if (memcmp(pv->u.str, str, plen) == 0)
  ------------------
  |  Branch (1049:9): [True: 240k, False: 281k]
  ------------------
 1050|   240k|      return i;
 1051|   522k|  }
 1052|       |
 1053|  18.5k|  pv = lit_pool_extend(s);
 1054|       |
 1055|  18.5k|  if (mrb_ro_data_p(str)) {
  ------------------
  |  Branch (1055:7): [True: 0, False: 18.5k]
  ------------------
 1056|      0|    pv->tt = (uint32_t)(len<<2) | IREP_TT_SSTR;
 1057|      0|    pv->u.str = str;
 1058|      0|  }
 1059|  18.5k|  else {
 1060|  18.5k|    char *p;
 1061|  18.5k|    pv->tt = (uint32_t)(len<<2) | IREP_TT_STR;
 1062|  18.5k|    p = (char*)codegen_realloc(s, NULL, len+1);
 1063|  18.5k|    memcpy(p, str, len);
 1064|  18.5k|    p[len] = '\0';
 1065|  18.5k|    pv->u.str = p;
 1066|  18.5k|  }
 1067|       |
 1068|  18.5k|  return i;
 1069|   258k|}

mrb_reserved_word:
  105|   459k|{
  106|   459k|  static const struct kwtable wordlist[] =
  107|   459k|    {
  108|   459k|      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
  109|   459k|#line 20 "mrbgems/mruby-compiler/core/keywords"
  110|   459k|      {"break",        {keyword_break,       keyword_break},       EXPR_MID},
  111|   459k|#line 25 "mrbgems/mruby-compiler/core/keywords"
  112|   459k|      {"else",         {keyword_else,        keyword_else},        EXPR_BEG},
  113|   459k|#line 35 "mrbgems/mruby-compiler/core/keywords"
  114|   459k|      {"nil",          {keyword_nil,         keyword_nil},         EXPR_END},
  115|   459k|#line 28 "mrbgems/mruby-compiler/core/keywords"
  116|   459k|      {"ensure",       {keyword_ensure,      keyword_ensure},      EXPR_BEG},
  117|   459k|#line 27 "mrbgems/mruby-compiler/core/keywords"
  118|   459k|      {"end",          {keyword_end,         keyword_end},         EXPR_END},
  119|   459k|#line 44 "mrbgems/mruby-compiler/core/keywords"
  120|   459k|      {"then",         {keyword_then,        keyword_then},        EXPR_BEG},
  121|   459k|#line 36 "mrbgems/mruby-compiler/core/keywords"
  122|   459k|      {"not",          {keyword_not,         keyword_not},         EXPR_ARG},
  123|   459k|#line 29 "mrbgems/mruby-compiler/core/keywords"
  124|   459k|      {"false",        {keyword_false,       keyword_false},       EXPR_END},
  125|   459k|#line 42 "mrbgems/mruby-compiler/core/keywords"
  126|   459k|      {"self",         {keyword_self,        keyword_self},        EXPR_END},
  127|   459k|#line 26 "mrbgems/mruby-compiler/core/keywords"
  128|   459k|      {"elsif",        {keyword_elsif,       keyword_elsif},       EXPR_VALUE},
  129|   459k|#line 39 "mrbgems/mruby-compiler/core/keywords"
  130|   459k|      {"rescue",       {keyword_rescue,      modifier_rescue},     EXPR_MID},
  131|   459k|#line 45 "mrbgems/mruby-compiler/core/keywords"
  132|   459k|      {"true",         {keyword_true,        keyword_true},        EXPR_END},
  133|   459k|#line 48 "mrbgems/mruby-compiler/core/keywords"
  134|   459k|      {"until",        {keyword_until,       modifier_until},      EXPR_VALUE},
  135|   459k|#line 47 "mrbgems/mruby-compiler/core/keywords"
  136|   459k|      {"unless",       {keyword_unless,      modifier_unless},     EXPR_VALUE},
  137|   459k|#line 41 "mrbgems/mruby-compiler/core/keywords"
  138|   459k|      {"return",       {keyword_return,      keyword_return},      EXPR_MID},
  139|   459k|#line 23 "mrbgems/mruby-compiler/core/keywords"
  140|   459k|      {"def",          {keyword_def,         keyword_def},         EXPR_FNAME},
  141|   459k|#line 18 "mrbgems/mruby-compiler/core/keywords"
  142|   459k|      {"and",          {keyword_and,         keyword_and},         EXPR_VALUE},
  143|   459k|#line 24 "mrbgems/mruby-compiler/core/keywords"
  144|   459k|      {"do",           {keyword_do,          keyword_do},          EXPR_BEG},
  145|   459k|#line 51 "mrbgems/mruby-compiler/core/keywords"
  146|   459k|      {"yield",        {keyword_yield,       keyword_yield},       EXPR_ARG},
  147|   459k|#line 30 "mrbgems/mruby-compiler/core/keywords"
  148|   459k|      {"for",          {keyword_for,         keyword_for},         EXPR_VALUE},
  149|   459k|#line 46 "mrbgems/mruby-compiler/core/keywords"
  150|   459k|      {"undef",        {keyword_undef,       keyword_undef},       EXPR_FNAME},
  151|   459k|#line 37 "mrbgems/mruby-compiler/core/keywords"
  152|   459k|      {"or",           {keyword_or,          keyword_or},          EXPR_VALUE},
  153|   459k|#line 32 "mrbgems/mruby-compiler/core/keywords"
  154|   459k|      {"in",           {keyword_in,          keyword_in},          EXPR_VALUE},
  155|   459k|#line 49 "mrbgems/mruby-compiler/core/keywords"
  156|   459k|      {"when",         {keyword_when,        keyword_when},        EXPR_VALUE},
  157|   459k|#line 40 "mrbgems/mruby-compiler/core/keywords"
  158|   459k|      {"retry",        {keyword_retry,       keyword_retry},       EXPR_END},
  159|   459k|#line 31 "mrbgems/mruby-compiler/core/keywords"
  160|   459k|      {"if",           {keyword_if,          modifier_if},         EXPR_VALUE},
  161|   459k|#line 21 "mrbgems/mruby-compiler/core/keywords"
  162|   459k|      {"case",         {keyword_case,        keyword_case},        EXPR_VALUE},
  163|   459k|#line 38 "mrbgems/mruby-compiler/core/keywords"
  164|   459k|      {"redo",         {keyword_redo,        keyword_redo},        EXPR_END},
  165|   459k|#line 34 "mrbgems/mruby-compiler/core/keywords"
  166|   459k|      {"next",         {keyword_next,        keyword_next},        EXPR_MID},
  167|   459k|#line 43 "mrbgems/mruby-compiler/core/keywords"
  168|   459k|      {"super",        {keyword_super,       keyword_super},       EXPR_ARG},
  169|   459k|#line 33 "mrbgems/mruby-compiler/core/keywords"
  170|   459k|      {"module",       {keyword_module,      keyword_module},      EXPR_VALUE},
  171|   459k|#line 19 "mrbgems/mruby-compiler/core/keywords"
  172|   459k|      {"begin",        {keyword_begin,       keyword_begin},       EXPR_BEG},
  173|   459k|#line 14 "mrbgems/mruby-compiler/core/keywords"
  174|   459k|      {"__LINE__",     {keyword__LINE__,     keyword__LINE__},     EXPR_END},
  175|   459k|#line 13 "mrbgems/mruby-compiler/core/keywords"
  176|   459k|      {"__FILE__",     {keyword__FILE__,     keyword__FILE__},     EXPR_END},
  177|   459k|#line 12 "mrbgems/mruby-compiler/core/keywords"
  178|   459k|      {"__ENCODING__", {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END},
  179|   459k|#line 16 "mrbgems/mruby-compiler/core/keywords"
  180|   459k|      {"END",          {keyword_END,         keyword_END},         EXPR_END},
  181|   459k|#line 17 "mrbgems/mruby-compiler/core/keywords"
  182|   459k|      {"alias",        {keyword_alias,       keyword_alias},       EXPR_FNAME},
  183|   459k|#line 15 "mrbgems/mruby-compiler/core/keywords"
  184|   459k|      {"BEGIN",        {keyword_BEGIN,       keyword_BEGIN},       EXPR_END},
  185|   459k|      {""},
  186|   459k|#line 22 "mrbgems/mruby-compiler/core/keywords"
  187|   459k|      {"class",        {keyword_class,       keyword_class},       EXPR_CLASS},
  188|   459k|      {""}, {""},
  189|   459k|#line 50 "mrbgems/mruby-compiler/core/keywords"
  190|   459k|      {"while",        {keyword_while,       modifier_while},      EXPR_VALUE}
  191|   459k|    };
  192|       |
  193|   459k|  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
  ------------------
  |  |   44|   919k|#define MAX_WORD_LENGTH 12
  ------------------
                if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
  ------------------
  |  |   43|   459k|#define MIN_WORD_LENGTH 2
  ------------------
  |  Branch (193:7): [True: 459k, False: 0]
  |  Branch (193:33): [True: 459k, False: 0]
  ------------------
  194|   459k|    {
  195|   459k|      register unsigned int key = hash (str, len);
  196|       |
  197|   459k|      if (key <= MAX_HASH_VALUE)
  ------------------
  |  |   46|   459k|#define MAX_HASH_VALUE 50
  ------------------
  |  Branch (197:11): [True: 129k, False: 330k]
  ------------------
  198|   129k|        {
  199|   129k|          register const char *s = wordlist[key].name;
  200|       |
  201|   129k|          if (*str == *s && !strcmp (str + 1, s + 1))
  ------------------
  |  Branch (201:15): [True: 125k, False: 3.49k]
  |  Branch (201:29): [True: 125k, False: 0]
  ------------------
  202|   125k|            return &wordlist[key];
  203|   129k|        }
  204|   459k|    }
  205|   334k|  return 0;
  206|   459k|}
y.tab.c:hash:
   58|   459k|{
   59|   459k|  static const unsigned char asso_values[] =
   60|   459k|    {
   61|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   62|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   63|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   64|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   65|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   66|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   67|   459k|      51, 51, 51, 51, 51, 51, 14, 51, 16,  8,
   68|   459k|      11, 13, 51, 51, 51, 51, 10, 51, 13, 51,
   69|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   70|   459k|      51, 51, 51, 51, 51, 11, 51, 13,  1, 26,
   71|   459k|       4,  1,  8, 28, 51, 23, 51,  1,  1, 27,
   72|   459k|       5, 19, 21, 51,  8,  3,  3, 11, 51, 21,
   73|   459k|      24, 16, 51, 51, 51, 51, 51, 51, 51, 51,
   74|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   75|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   76|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   77|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   78|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   79|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   80|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   81|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   82|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   83|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   84|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   85|   459k|      51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
   86|   459k|      51, 51, 51, 51, 51, 51
   87|   459k|    };
   88|   459k|  register unsigned int hval = len;
   89|       |
   90|   459k|  switch (hval)
   91|   459k|    {
   92|   440k|      default:
  ------------------
  |  Branch (92:7): [True: 440k, False: 19.5k]
  ------------------
   93|   440k|        hval += asso_values[(unsigned char)str[2]];
   94|       |      /*FALLTHROUGH*/
   95|   459k|      case 2:
  ------------------
  |  Branch (95:7): [True: 19.5k, False: 440k]
  ------------------
   96|   459k|      case 1:
  ------------------
  |  Branch (96:7): [True: 0, False: 459k]
  ------------------
   97|   459k|        hval += asso_values[(unsigned char)str[0]];
   98|   459k|        break;
   99|   459k|    }
  100|   459k|  return hval + asso_values[(unsigned char)str[len - 1]];
  101|   459k|}

mrb_parser_parse:
13214|  1.74k|{
13215|  1.74k|  struct mrb_jmpbuf buf1;
13216|  1.74k|  struct mrb_jmpbuf *prev = p->mrb->jmp;
13217|  1.74k|  p->mrb->jmp = &buf1;
13218|       |
13219|  1.74k|  MRB_TRY(p->mrb->jmp) {
  ------------------
  |  |   44|  1.74k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  1.74k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 1.74k, False: 0]
  |  |  ------------------
  ------------------
13220|  1.74k|    int n = 1;
13221|       |
13222|  1.74k|    p->cmd_start = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
13223|  1.74k|    p->in_def = p->in_single = 0;
13224|  1.74k|    p->nerr = p->nwarn = 0;
13225|  1.74k|    p->lex_strterm = NULL;
13226|  1.74k|    parser_init_cxt(p, c);
13227|       |
13228|  1.74k|    n = yyparse(p);
13229|  1.74k|    if (n != 0 || p->nerr > 0) {
  ------------------
  |  Branch (13229:9): [True: 0, False: 1.74k]
  |  Branch (13229:19): [True: 14, False: 1.73k]
  ------------------
13230|     14|      p->tree = 0;
13231|     14|      p->mrb->jmp = prev;
13232|     14|      return;
13233|     14|    }
13234|  1.73k|    parser_update_cxt(p, c);
13235|  1.73k|    if (c && c->dump_result) {
  ------------------
  |  Branch (13235:9): [True: 0, False: 1.73k]
  |  Branch (13235:14): [True: 0, False: 0]
  ------------------
13236|      0|      mrb_parser_dump(p->mrb, p->tree, 0);
13237|      0|    }
13238|  1.73k|  }
13239|  1.73k|  MRB_CATCH(p->mrb->jmp) {
  ------------------
  |  |   45|  1.73k|#define MRB_CATCH(buf) } else {
  ------------------
13240|      0|    p->nerr++;
13241|      0|    if (p->mrb->exc == NULL) {
  ------------------
  |  Branch (13241:9): [True: 0, False: 0]
  ------------------
13242|      0|      yyerror(p, "memory allocation error");
13243|      0|      p->nerr++;
13244|      0|      p->tree = 0;
13245|      0|    }
13246|      0|  }
13247|  1.73k|  MRB_END_EXC(p->jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
13248|  1.73k|  p->mrb->jmp = prev;
13249|  1.73k|}
mrb_parser_new:
13253|  1.74k|{
13254|  1.74k|  mrb_pool *pool;
13255|  1.74k|  parser_state *p;
13256|  1.74k|  static const parser_state parser_state_zero = { 0 };
13257|       |
13258|  1.74k|  pool = mrb_pool_open(mrb);
13259|  1.74k|  if (!pool) return NULL;
  ------------------
  |  Branch (13259:7): [True: 0, False: 1.74k]
  ------------------
13260|  1.74k|  p = (parser_state*)mrb_pool_alloc(pool, sizeof(parser_state));
13261|  1.74k|  if (!p) return NULL;
  ------------------
  |  Branch (13261:7): [True: 0, False: 1.74k]
  ------------------
13262|       |
13263|  1.74k|  *p = parser_state_zero;
13264|  1.74k|  p->mrb = mrb;
13265|  1.74k|  p->pool = pool;
13266|       |
13267|  1.74k|  p->s = p->send = NULL;
13268|  1.74k|#ifndef MRB_NO_STDIO
13269|  1.74k|  p->f = NULL;
13270|  1.74k|#endif
13271|       |
13272|  1.74k|  p->cmd_start = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
13273|  1.74k|  p->in_def = p->in_single = 0;
13274|       |
13275|  1.74k|  p->capture_errors = FALSE;
  ------------------
  |  |   51|  1.74k|#  define FALSE 0
  ------------------
13276|  1.74k|  p->lineno = 1;
13277|  1.74k|  p->column = 0;
13278|       |#if defined(PARSER_TEST) || defined(PARSER_DEBUG)
13279|       |  yydebug = 1;
13280|       |#endif
13281|  1.74k|  p->tsiz = MRB_PARSER_TOKBUF_SIZE;
  ------------------
  |  |  112|  1.74k|#define MRB_PARSER_TOKBUF_SIZE 256
  ------------------
13282|  1.74k|  p->tokbuf = p->buf;
13283|       |
13284|  1.74k|  p->lex_strterm = NULL;
13285|       |
13286|  1.74k|  p->current_filename_index = -1;
13287|  1.74k|  p->filename_table = NULL;
13288|  1.74k|  p->filename_table_length = 0;
13289|       |
13290|  1.74k|  return p;
13291|  1.74k|}
mrb_parser_free:
13294|  1.74k|mrb_parser_free(parser_state *p) {
13295|  1.74k|  if (p->tokbuf != p->buf) {
  ------------------
  |  Branch (13295:7): [True: 0, False: 1.74k]
  ------------------
13296|      0|    mrb_free(p->mrb, p->tokbuf);
13297|      0|  }
13298|  1.74k|  mrb_pool_close(p->pool);
13299|  1.74k|}
mrb_parse_nstring:
13420|  1.74k|{
13421|  1.74k|  parser_state *p;
13422|       |
13423|  1.74k|  p = mrb_parser_new(mrb);
13424|  1.74k|  if (!p) return NULL;
  ------------------
  |  Branch (13424:7): [True: 0, False: 1.74k]
  ------------------
13425|  1.74k|  p->s = s;
13426|  1.74k|  p->send = s + len;
13427|       |
13428|  1.74k|  mrb_parser_parse(p, c);
13429|  1.74k|  return p;
13430|  1.74k|}
mrb_load_exec:
13440|  1.74k|{
13441|  1.74k|  struct RClass *target = mrb->object_class;
13442|  1.74k|  struct RProc *proc;
13443|  1.74k|  mrb_value v;
13444|  1.74k|  mrb_int keep = 0;
13445|       |
13446|  1.74k|  if (!p) {
  ------------------
  |  Branch (13446:7): [True: 0, False: 1.74k]
  ------------------
13447|      0|    return mrb_undef_value();
13448|      0|  }
13449|  1.74k|  if (!p->tree || p->nerr) {
  ------------------
  |  Branch (13449:7): [True: 14, False: 1.73k]
  |  Branch (13449:19): [True: 0, False: 1.73k]
  ------------------
13450|     14|    if (c) c->parser_nerr = p->nerr;
  ------------------
  |  Branch (13450:9): [True: 0, False: 14]
  ------------------
13451|     14|    if (p->capture_errors) {
  ------------------
  |  Branch (13451:9): [True: 0, False: 14]
  ------------------
13452|      0|      char buf[256];
13453|       |
13454|      0|      strcpy(buf, "line ");
13455|      0|      dump_int(p->error_buffer[0].lineno, buf+5);
13456|      0|      strcat(buf, ": ");
13457|      0|      strncat(buf, p->error_buffer[0].message, sizeof(buf) - strlen(buf) - 1);
13458|      0|      mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, strlen(buf)));
  ------------------
  |  |   34|      0|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
13459|      0|      mrb_parser_free(p);
13460|      0|      return mrb_undef_value();
13461|      0|    }
13462|     14|    else {
13463|     14|      if (mrb->exc == NULL) {
  ------------------
  |  Branch (13463:11): [True: 14, False: 0]
  ------------------
13464|     14|        mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
  ------------------
  |  |   34|     14|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|     14|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
13465|     14|      }
13466|     14|      mrb_parser_free(p);
13467|     14|      return mrb_undef_value();
13468|     14|    }
13469|     14|  }
13470|  1.73k|  proc = mrb_generate_code(mrb, p);
13471|  1.73k|  mrb_parser_free(p);
13472|  1.73k|  if (proc == NULL) {
  ------------------
  |  Branch (13472:7): [True: 189, False: 1.54k]
  ------------------
13473|    189|    if (mrb->exc == NULL) {
  ------------------
  |  Branch (13473:9): [True: 189, False: 0]
  ------------------
13474|    189|      mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
  ------------------
  |  |   34|    189|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|    189|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
13475|    189|    }
13476|    189|    return mrb_undef_value();
13477|    189|  }
13478|  1.54k|  if (c) {
  ------------------
  |  Branch (13478:7): [True: 0, False: 1.54k]
  ------------------
13479|      0|    if (c->dump_result) mrb_codedump_all(mrb, proc);
  ------------------
  |  Branch (13479:9): [True: 0, False: 0]
  ------------------
13480|      0|    if (c->no_exec) return mrb_obj_value(proc);
  ------------------
  |  Branch (13480:9): [True: 0, False: 0]
  ------------------
13481|      0|    if (c->target_class) {
  ------------------
  |  Branch (13481:9): [True: 0, False: 0]
  ------------------
13482|      0|      target = c->target_class;
13483|      0|    }
13484|      0|    if (c->keep_lv) {
  ------------------
  |  Branch (13484:9): [True: 0, False: 0]
  ------------------
13485|      0|      keep = c->slen + 1;
13486|      0|    }
13487|      0|    else {
13488|      0|      c->keep_lv = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
13489|      0|    }
13490|      0|  }
13491|  1.54k|  MRB_PROC_SET_TARGET_CLASS(proc, target);
  ------------------
  |  |   75|  1.54k|#define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
  |  |   76|  1.54k|  if (MRB_PROC_ENV_P(p)) {\
  |  |  ------------------
  |  |  |  |   72|  1.54k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  1.54k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 1.54k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|    (p)->e.env->c = (tc);\
  |  |   78|      0|    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)(tc));\
  |  |   79|      0|  }\
  |  |   80|  1.54k|  else {\
  |  |   81|  1.54k|    (p)->e.target_class = (tc);\
  |  |   82|  1.54k|    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)(tc));\
  |  |   83|  1.54k|  }\
  |  |   84|  1.54k|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
13492|  1.54k|  if (mrb->c->ci) {
  ------------------
  |  Branch (13492:7): [True: 1.54k, False: 0]
  ------------------
13493|  1.54k|    mrb_vm_ci_target_class_set(mrb->c->ci, target);
13494|  1.54k|  }
13495|  1.54k|  v = mrb_top_run(mrb, proc, mrb_top_self(mrb), keep);
13496|  1.54k|  if (mrb->exc) return mrb_nil_value();
  ------------------
  |  Branch (13496:7): [True: 443, False: 1.09k]
  ------------------
13497|  1.09k|  return v;
13498|  1.54k|}
mrb_load_nstring_cxt:
13566|  1.74k|{
13567|  1.74k|  return mrb_load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
13568|  1.74k|}
mrb_load_string_cxt:
13578|  1.74k|{
13579|  1.74k|  return mrb_load_nstring_cxt(mrb, s, strlen(s), c);
13580|  1.74k|}
mrb_load_string:
13584|  1.74k|{
13585|  1.74k|  return mrb_load_string_cxt(mrb, s, NULL);
13586|  1.74k|}
y.tab.c:parser_init_cxt:
13168|  1.74k|{
13169|  1.74k|  if (!cxt) return;
  ------------------
  |  Branch (13169:7): [True: 1.74k, False: 0]
  ------------------
13170|      0|  if (cxt->filename) mrb_parser_set_filename(p, cxt->filename);
  ------------------
  |  Branch (13170:7): [True: 0, False: 0]
  ------------------
13171|      0|  if (cxt->lineno) p->lineno = cxt->lineno;
  ------------------
  |  Branch (13171:7): [True: 0, False: 0]
  ------------------
13172|      0|  if (cxt->syms) {
  ------------------
  |  Branch (13172:7): [True: 0, False: 0]
  ------------------
13173|      0|    int i;
13174|       |
13175|      0|    p->locals = cons(0,0);
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
13176|      0|    for (i=0; i<cxt->slen; i++) {
  ------------------
  |  Branch (13176:15): [True: 0, False: 0]
  ------------------
13177|      0|      local_add_f(p, cxt->syms[i]);
13178|      0|    }
13179|      0|  }
13180|      0|  p->capture_errors = cxt->capture_errors;
13181|      0|  p->no_optimize = cxt->no_optimize;
13182|      0|  p->no_ext_ops = cxt->no_ext_ops;
13183|      0|  p->upper = cxt->upper;
13184|      0|  if (cxt->partial_hook) {
  ------------------
  |  Branch (13184:7): [True: 0, False: 0]
  ------------------
13185|      0|    p->cxt = cxt;
13186|      0|  }
13187|      0|}
y.tab.c:cons_gen:
  189|  10.4M|{
  190|  10.4M|  node *c;
  191|       |
  192|  10.4M|  if (p->cells) {
  ------------------
  |  Branch (192:7): [True: 3.21M, False: 7.24M]
  ------------------
  193|  3.21M|    c = p->cells;
  194|  3.21M|    p->cells = p->cells->cdr;
  195|  3.21M|  }
  196|  7.24M|  else {
  197|  7.24M|    c = (node*)parser_palloc(p, sizeof(mrb_ast_node));
  198|  7.24M|  }
  199|       |
  200|  10.4M|  c->car = car;
  201|  10.4M|  c->cdr = cdr;
  202|  10.4M|  c->lineno = p->lineno;
  203|  10.4M|  c->filename_index = p->current_filename_index;
  204|       |  /* beginning of next partial file; need to point the previous file */
  205|  10.4M|  if (p->lineno == 0 && p->current_filename_index > 0) {
  ------------------
  |  Branch (205:7): [True: 0, False: 10.4M]
  |  Branch (205:25): [True: 0, False: 0]
  ------------------
  206|      0|    c->filename_index--;
  207|      0|  }
  208|  10.4M|  return c;
  209|  10.4M|}
y.tab.c:local_add_f:
  375|   162k|{
  376|   162k|  if (p->locals) {
  ------------------
  |  Branch (376:7): [True: 162k, False: 0]
  ------------------
  377|   162k|    node *n = p->locals->car;
  378|  75.5M|    while (n) {
  ------------------
  |  Branch (378:12): [True: 75.4M, False: 162k]
  ------------------
  379|  75.4M|      if (sym(n->car) == sym) {
  ------------------
  |  |  132|  75.4M|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
  |  Branch (379:11): [True: 0, False: 75.4M]
  ------------------
  380|      0|        mrb_int len;
  381|      0|        const char* name = mrb_sym_name_len(p->mrb, sym, &len);
  382|      0|        if (len > 0 && name[0] != '_') {
  ------------------
  |  Branch (382:13): [True: 0, False: 0]
  |  Branch (382:24): [True: 0, False: 0]
  ------------------
  383|      0|          yyerror(p, "duplicated argument name");
  384|      0|          return;
  385|      0|        }
  386|      0|      }
  387|  75.4M|      n = n->cdr;
  388|  75.4M|    }
  389|   162k|    p->locals->car = push(p->locals->car, nsym(sym));
  ------------------
  |  |  268|   162k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|   162k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
  390|   162k|  }
  391|   162k|}
y.tab.c:append_gen:
  256|  1.70M|{
  257|  1.70M|  node *c = a;
  258|       |
  259|  1.70M|  if (!a) return b;
  ------------------
  |  Branch (259:7): [True: 813k, False: 889k]
  ------------------
  260|   889k|  if (!b) return a;
  ------------------
  |  Branch (260:7): [True: 0, False: 889k]
  ------------------
  261|  1.85G|  while (c->cdr) {
  ------------------
  |  Branch (261:10): [True: 1.85G, False: 889k]
  ------------------
  262|  1.85G|    c = c->cdr;
  263|  1.85G|  }
  264|   889k|  c->cdr = b;
  265|   889k|  return a;
  266|   889k|}
y.tab.c:list1_gen:
  214|  1.96M|{
  215|  1.96M|  return cons(a, 0);
  ------------------
  |  |  210|  1.96M|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  216|  1.96M|}
y.tab.c:yyparse:
 6227|  1.74k|{
 6228|       |/* Lookahead token kind.  */
 6229|  1.74k|int yychar;
 6230|       |
 6231|       |
 6232|       |/* The semantic value of the lookahead symbol.  */
 6233|       |/* Default value used for initialization, for pacifying older GCCs
 6234|       |   or non-GCC compilers.  */
 6235|  1.74k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
  ------------------
  |  | 2205|  1.74k|# define YY_INITIAL_VALUE(Value) Value
  ------------------
 6236|  1.74k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
  ------------------
  |  | 2205|  1.74k|# define YY_INITIAL_VALUE(Value) Value
  ------------------
 6237|       |
 6238|       |    /* Number of syntax errors so far.  */
 6239|  1.74k|    int yynerrs = 0;
 6240|       |
 6241|  1.74k|    yy_state_fast_t yystate = 0;
 6242|       |    /* Number of tokens to shift before error messages enabled.  */
 6243|  1.74k|    int yyerrstatus = 0;
 6244|       |
 6245|       |    /* Refer to the stacks through separate pointers, to allow yyoverflow
 6246|       |       to reallocate them elsewhere.  */
 6247|       |
 6248|       |    /* Their size.  */
 6249|  1.74k|    YYPTRDIFF_T yystacksize = YYINITDEPTH;
  ------------------
  |  | 2112|  1.74k|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  ------------------
                  YYPTRDIFF_T yystacksize = YYINITDEPTH;
  ------------------
  |  | 5911|  1.74k|# define YYINITDEPTH 200
  ------------------
 6250|       |
 6251|       |    /* The state stack: array, bottom, top.  */
 6252|  1.74k|    yy_state_t yyssa[YYINITDEPTH];
 6253|  1.74k|    yy_state_t *yyss = yyssa;
 6254|  1.74k|    yy_state_t *yyssp = yyss;
 6255|       |
 6256|       |    /* The semantic value stack: array, bottom, top.  */
 6257|  1.74k|    YYSTYPE yyvsa[YYINITDEPTH];
 6258|  1.74k|    YYSTYPE *yyvs = yyvsa;
 6259|  1.74k|    YYSTYPE *yyvsp = yyvs;
 6260|       |
 6261|  1.74k|  int yyn;
 6262|       |  /* The return value of yyparse.  */
 6263|  1.74k|  int yyresult;
 6264|       |  /* Lookahead symbol kind.  */
 6265|  1.74k|  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
 6266|       |  /* The variables used to return semantic value and location from the
 6267|       |     action routines.  */
 6268|  1.74k|  YYSTYPE yyval;
 6269|       |
 6270|       |  /* Buffer for error messages, and its allocated size.  */
 6271|  1.74k|  char yymsgbuf[128];
 6272|  1.74k|  char *yymsg = yymsgbuf;
 6273|  1.74k|  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
  ------------------
  |  | 2112|  1.74k|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  ------------------
 6274|       |
 6275|  1.74k|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 6276|       |
 6277|       |  /* The number of symbols on the RHS of the reduced rule.
 6278|       |     Keep to zero when no symbol should be popped.  */
 6279|  1.74k|  int yylen = 0;
 6280|       |
 6281|  1.74k|  YYDPRINTF ((stderr, "Starting parse\n"));
  ------------------
  |  | 5902|  1.74k|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 6282|       |
 6283|  1.74k|  yychar = YYEMPTY; /* Cause a token to be read.  */
 6284|       |
 6285|  1.74k|  goto yysetstate;
 6286|       |
 6287|       |
 6288|       |/*------------------------------------------------------------.
 6289|       || yynewstate -- push a new state, which is found in yystate.  |
 6290|       |`------------------------------------------------------------*/
 6291|  16.4M|yynewstate:
 6292|       |  /* In all cases, when you get here, the value and location stacks
 6293|       |     have just been pushed.  So pushing a state here evens the stacks.  */
 6294|  16.4M|  yyssp++;
 6295|       |
 6296|       |
 6297|       |/*--------------------------------------------------------------------.
 6298|       || yysetstate -- set current state (the top of the stack) to yystate.  |
 6299|       |`--------------------------------------------------------------------*/
 6300|  16.4M|yysetstate:
 6301|  16.4M|  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  ------------------
  |  | 5902|  16.4M|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 6302|  16.4M|  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  ------------------
  |  | 2228|  16.4M|#define YY_ASSERT(E) ((void) (0 && (E)))
  |  |  ------------------
  |  |  |  Branch (2228:31): [Folded - Ignored]
  |  |  |  Branch (2228:37): [True: 0, False: 0]
  |  |  |  Branch (2228:37): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 6303|  16.4M|  YY_IGNORE_USELESS_CAST_BEGIN
 6304|  16.4M|  *yyssp = YY_CAST (yy_state_t, yystate);
  ------------------
  |  | 1519|  16.4M|#   define YY_CAST(Type, Val) ((Type) (Val))
  ------------------
 6305|  16.4M|  YY_IGNORE_USELESS_CAST_END
 6306|  16.4M|  YY_STACK_PRINT (yyss, yyssp);
 6307|       |
 6308|  16.4M|  if (yyss + yystacksize - 1 <= yyssp)
  ------------------
  |  Branch (6308:7): [True: 3, False: 16.4M]
  ------------------
 6309|       |#if !defined yyoverflow && !defined YYSTACK_RELOCATE
 6310|       |    YYNOMEM;
 6311|       |#else
 6312|      3|    {
 6313|       |      /* Get the current used size of the three stacks, in elements.  */
 6314|      3|      YYPTRDIFF_T yysize = yyssp - yyss + 1;
  ------------------
  |  | 2112|      3|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  ------------------
 6315|       |
 6316|       |# if defined yyoverflow
 6317|       |      {
 6318|       |        /* Give user a chance to reallocate the stack.  Use copies of
 6319|       |           these so that the &'s don't force the real ones into
 6320|       |           memory.  */
 6321|       |        yy_state_t *yyss1 = yyss;
 6322|       |        YYSTYPE *yyvs1 = yyvs;
 6323|       |
 6324|       |        /* Each stack pointer address is followed by the size of the
 6325|       |           data in use in that stack, in bytes.  This used to be a
 6326|       |           conditional around just the two extra args, but that might
 6327|       |           be undefined if yyoverflow is a macro.  */
 6328|       |        yyoverflow (YY_("memory exhausted"),
 6329|       |                    &yyss1, yysize * YYSIZEOF (*yyssp),
 6330|       |                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
 6331|       |                    &yystacksize);
 6332|       |        yyss = yyss1;
 6333|       |        yyvs = yyvs1;
 6334|       |      }
 6335|       |# else /* defined YYSTACK_RELOCATE */
 6336|       |      /* Extend the stack our own way.  */
 6337|      3|      if (YYMAXDEPTH <= yystacksize)
  ------------------
  |  | 5922|      3|# define YYMAXDEPTH 10000
  ------------------
  |  Branch (6337:11): [True: 0, False: 3]
  ------------------
 6338|      0|        YYNOMEM;
  ------------------
  |  | 5754|      0|#define YYNOMEM         goto yyexhaustedlab
  ------------------
 6339|      3|      yystacksize *= 2;
 6340|      3|      if (YYMAXDEPTH < yystacksize)
  ------------------
  |  | 5922|      3|# define YYMAXDEPTH 10000
  ------------------
  |  Branch (6340:11): [True: 0, False: 3]
  ------------------
 6341|      0|        yystacksize = YYMAXDEPTH;
  ------------------
  |  | 5922|      0|# define YYMAXDEPTH 10000
  ------------------
 6342|       |
 6343|      3|      {
 6344|      3|        yy_state_t *yyss1 = yyss;
 6345|      3|        union yyalloc *yyptr =
 6346|      3|          YY_CAST (union yyalloc *,
  ------------------
  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  ------------------
 6347|      3|                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
 6348|      3|        if (! yyptr)
  ------------------
  |  Branch (6348:13): [True: 0, False: 3]
  ------------------
 6349|      0|          YYNOMEM;
  ------------------
  |  | 5754|      0|#define YYNOMEM         goto yyexhaustedlab
  ------------------
 6350|      3|        YYSTACK_RELOCATE (yyss_alloc, yyss);
  ------------------
  |  | 2325|      3|    do                                                                  \
  |  | 2326|      3|      {                                                                 \
  |  | 2327|      3|        YYPTRDIFF_T yynewbytes;                                         \
  |  |  ------------------
  |  |  |  | 2112|      3|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  |  |  ------------------
  |  | 2328|      3|        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
  |  |  ------------------
  |  |  |  | 2343|      3|      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2329|      3|        Stack = &yyptr->Stack_alloc;                                    \
  |  | 2330|      3|        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 2145|      3|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                       yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 2309|      3|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2145|      3|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2331|      3|        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
  |  |  ------------------
  |  |  |  | 2145|      3|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2332|      3|      }                                                                 \
  |  | 2333|      3|    while (0)
  |  |  ------------------
  |  |  |  Branch (2333:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6351|      3|        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
  ------------------
  |  | 2325|      3|    do                                                                  \
  |  | 2326|      3|      {                                                                 \
  |  | 2327|      3|        YYPTRDIFF_T yynewbytes;                                         \
  |  |  ------------------
  |  |  |  | 2112|      3|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  |  |  ------------------
  |  | 2328|      3|        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
  |  |  ------------------
  |  |  |  | 2343|      3|      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2329|      3|        Stack = &yyptr->Stack_alloc;                                    \
  |  | 2330|      3|        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 2145|      3|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                       yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 2309|      3|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2145|      3|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2331|      3|        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
  |  |  ------------------
  |  |  |  | 2145|      3|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1519|      3|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2332|      3|      }                                                                 \
  |  | 2333|      3|    while (0)
  |  |  ------------------
  |  |  |  Branch (2333:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6352|      3|#  undef YYSTACK_RELOCATE
 6353|      3|        if (yyss1 != yyssa)
  ------------------
  |  Branch (6353:13): [True: 0, False: 3]
  ------------------
 6354|      0|          YYSTACK_FREE (yyss1);
  ------------------
  |  | 2260|      0|#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  |  |  ------------------
  |  |  |  Branch (2260:56): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6355|      3|      }
 6356|      0|# endif
 6357|       |
 6358|      0|      yyssp = yyss + yysize - 1;
 6359|      3|      yyvsp = yyvs + yysize - 1;
 6360|       |
 6361|      3|      YY_IGNORE_USELESS_CAST_BEGIN
 6362|      3|      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
  ------------------
  |  | 5902|      3|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 6363|      3|                  YY_CAST (long, yystacksize)));
 6364|      3|      YY_IGNORE_USELESS_CAST_END
 6365|       |
 6366|      3|      if (yyss + yystacksize - 1 <= yyssp)
  ------------------
  |  Branch (6366:11): [True: 0, False: 3]
  ------------------
 6367|      0|        YYABORT;
  ------------------
  |  | 5752|      0|#define YYABORT         goto yyabortlab
  ------------------
 6368|      3|    }
 6369|  16.4M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 6370|       |
 6371|       |
 6372|  16.4M|  if (yystate == YYFINAL)
  ------------------
  |  | 2358|  16.4M|#define YYFINAL  3
  ------------------
  |  Branch (6372:7): [True: 1.74k, False: 16.4M]
  ------------------
 6373|  1.74k|    YYACCEPT;
  ------------------
  |  | 5751|  1.74k|#define YYACCEPT        goto yyacceptlab
  ------------------
 6374|       |
 6375|  16.4M|  goto yybackup;
 6376|       |
 6377|       |
 6378|       |/*-----------.
 6379|       || yybackup.  |
 6380|       |`-----------*/
 6381|  16.4M|yybackup:
 6382|       |  /* Do appropriate processing given the current state.  Read a
 6383|       |     lookahead token if we need one and don't already have one.  */
 6384|       |
 6385|       |  /* First try to decide what to do without reference to lookahead token.  */
 6386|  16.4M|  yyn = yypact[yystate];
 6387|  16.4M|  if (yypact_value_is_default (yyn))
  ------------------
  |  | 2581|  16.4M|  ((Yyn) == YYPACT_NINF)
  |  |  ------------------
  |  |  |  | 2578|  16.4M|#define YYPACT_NINF (-868)
  |  |  ------------------
  |  |  |  Branch (2581:3): [True: 6.11M, False: 10.3M]
  |  |  ------------------
  ------------------
 6388|  6.11M|    goto yydefault;
 6389|       |
 6390|       |  /* Not known => get a lookahead token if don't already have one.  */
 6391|       |
 6392|       |  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
 6393|  10.3M|  if (yychar == YYEMPTY)
  ------------------
  |  Branch (6393:7): [True: 3.88M, False: 6.43M]
  ------------------
 6394|  3.88M|    {
 6395|  3.88M|      YYDPRINTF ((stderr, "Reading a token\n"));
  ------------------
  |  | 5902|  3.88M|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 6396|  3.88M|      yychar = yylex (&yylval, p);
 6397|  3.88M|    }
 6398|       |
 6399|  10.3M|  if (yychar <= YYEOF)
  ------------------
  |  Branch (6399:7): [True: 3.49k, False: 10.3M]
  ------------------
 6400|  3.49k|    {
 6401|  3.49k|      yychar = YYEOF;
 6402|  3.49k|      yytoken = YYSYMBOL_YYEOF;
 6403|  3.49k|      YYDPRINTF ((stderr, "Now at end of input.\n"));
  ------------------
  |  | 5902|  3.49k|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 6404|  3.49k|    }
 6405|  10.3M|  else if (yychar == YYerror)
  ------------------
  |  Branch (6405:12): [True: 0, False: 10.3M]
  ------------------
 6406|      0|    {
 6407|       |      /* The scanner already issued an error message, process directly
 6408|       |         to error recovery.  But do not keep the error token as
 6409|       |         lookahead, it is too special and may lead us to an endless
 6410|       |         loop in error recovery. */
 6411|      0|      yychar = YYUNDEF;
 6412|      0|      yytoken = YYSYMBOL_YYerror;
 6413|      0|      goto yyerrlab1;
 6414|      0|    }
 6415|  10.3M|  else
 6416|  10.3M|    {
 6417|  10.3M|      yytoken = YYTRANSLATE (yychar);
  ------------------
  |  | 2378|  10.3M|  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
  |  |  ------------------
  |  |  |  | 2372|  10.3M|#define YYMAXUTOK   377
  |  |  ------------------
  |  |  |  Branch (2378:4): [True: 10.3M, False: 0]
  |  |  |  Branch (2378:18): [True: 10.3M, False: 0]
  |  |  ------------------
  |  | 2379|  10.3M|   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
  |  |  ------------------
  |  |  |  | 1519|  10.3M|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  |  | 2380|  10.3M|   : YYSYMBOL_YYUNDEF)
  ------------------
 6418|  10.3M|      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 6419|  10.3M|    }
 6420|       |
 6421|       |  /* If the proper action on seeing token YYTOKEN is to reduce or to
 6422|       |     detect an error, take that action.  */
 6423|  10.3M|  yyn += yytoken;
 6424|  10.3M|  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
  ------------------
  |  | 2360|  10.3M|#define YYLAST   13092
  ------------------
  |  Branch (6424:7): [True: 0, False: 10.3M]
  |  Branch (6424:18): [True: 0, False: 10.3M]
  |  Branch (6424:34): [True: 6.04M, False: 4.27M]
  ------------------
 6425|  6.04M|    goto yydefault;
 6426|  4.27M|  yyn = yytable[yyn];
 6427|  4.27M|  if (yyn <= 0)
  ------------------
  |  Branch (6427:7): [True: 384k, False: 3.88M]
  ------------------
 6428|   384k|    {
 6429|   384k|      if (yytable_value_is_error (yyn))
  ------------------
  |  | 2586|   384k|  ((Yyn) == YYTABLE_NINF)
  |  |  ------------------
  |  |  |  | 2583|   384k|#define YYTABLE_NINF (-620)
  |  |  ------------------
  |  |  |  Branch (2586:3): [True: 0, False: 384k]
  |  |  ------------------
  ------------------
 6430|      0|        goto yyerrlab;
 6431|   384k|      yyn = -yyn;
 6432|   384k|      goto yyreduce;
 6433|   384k|    }
 6434|       |
 6435|       |  /* Count tokens shifted since error; after three, turn off error
 6436|       |     status.  */
 6437|  3.88M|  if (yyerrstatus)
  ------------------
  |  Branch (6437:7): [True: 0, False: 3.88M]
  ------------------
 6438|      0|    yyerrstatus--;
 6439|       |
 6440|       |  /* Shift the lookahead token.  */
 6441|  3.88M|  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 6442|  3.88M|  yystate = yyn;
 6443|  3.88M|  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 6444|  3.88M|  *++yyvsp = yylval;
 6445|  3.88M|  YY_IGNORE_MAYBE_UNINITIALIZED_END
 6446|       |
 6447|       |  /* Discard the shifted token.  */
 6448|  3.88M|  yychar = YYEMPTY;
 6449|  3.88M|  goto yynewstate;
 6450|       |
 6451|       |
 6452|       |/*-----------------------------------------------------------.
 6453|       || yydefault -- do the default action for the current state.  |
 6454|       |`-----------------------------------------------------------*/
 6455|  12.1M|yydefault:
 6456|  12.1M|  yyn = yydefact[yystate];
 6457|  12.1M|  if (yyn == 0)
  ------------------
  |  Branch (6457:7): [True: 0, False: 12.1M]
  ------------------
 6458|      0|    goto yyerrlab;
 6459|  12.1M|  goto yyreduce;
 6460|       |
 6461|       |
 6462|       |/*-----------------------------.
 6463|       || yyreduce -- do a reduction.  |
 6464|       |`-----------------------------*/
 6465|  12.5M|yyreduce:
 6466|       |  /* yyn is the number of a rule to reduce with.  */
 6467|  12.5M|  yylen = yyr2[yyn];
 6468|       |
 6469|       |  /* If YYLEN is nonzero, implement the default value of the action:
 6470|       |     '$$ = $1'.
 6471|       |
 6472|       |     Otherwise, the following line sets YYVAL to garbage.
 6473|       |     This behavior is undocumented and Bison
 6474|       |     users should not rely upon it.  Assigning to YYVAL
 6475|       |     unconditionally makes the parser a bit smaller, and it avoids a
 6476|       |     GCC warning that YYVAL may be used uninitialized.  */
 6477|  12.5M|  yyval = yyvsp[1-yylen];
 6478|       |
 6479|       |
 6480|  12.5M|  YY_REDUCE_PRINT (yyn);
 6481|  12.5M|  switch (yyn)
 6482|  12.5M|    {
 6483|  1.74k|  case 2: /* $@1: %empty  */
  ------------------
  |  Branch (6483:3): [True: 1.74k, False: 12.5M]
  ------------------
 6484|  1.74k|#line 1625 "mrbgems/mruby-compiler/core/parse.y"
 6485|  1.74k|                    {
 6486|  1.74k|                      p->lstate = EXPR_BEG;
 6487|  1.74k|                      if (!p->locals) p->locals = cons(0,0);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  |  Branch (6487:27): [True: 1.74k, False: 0]
  ------------------
 6488|  1.74k|                    }
 6489|  1.74k|#line 6490 "mrbgems/mruby-compiler/core/y.tab.c"
 6490|  1.74k|    break;
 6491|       |
 6492|  1.74k|  case 3: /* program: $@1 top_compstmt  */
  ------------------
  |  Branch (6492:3): [True: 1.74k, False: 12.5M]
  ------------------
 6493|  1.74k|#line 1630 "mrbgems/mruby-compiler/core/parse.y"
 6494|  1.74k|                    {
 6495|  1.74k|                      p->tree = new_scope(p, (yyvsp[0].nd));
 6496|  1.74k|                      NODE_LINENO(p->tree, (yyvsp[0].nd));
  ------------------
  |  |  125|  1.74k|#define NODE_LINENO(c,n) do {\
  |  |  126|  1.74k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 1.74k, False: 0]
  |  |  ------------------
  |  |  127|  1.74k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  1.74k|     (c)->lineno = (n)->lineno;\
  |  |  129|  1.74k|  }\
  |  |  130|  1.74k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6497|  1.74k|                    }
 6498|  1.74k|#line 6499 "mrbgems/mruby-compiler/core/y.tab.c"
 6499|  1.74k|    break;
 6500|       |
 6501|  1.74k|  case 4: /* top_compstmt: top_stmts opt_terms  */
  ------------------
  |  Branch (6501:3): [True: 1.74k, False: 12.5M]
  ------------------
 6502|  1.74k|#line 1637 "mrbgems/mruby-compiler/core/parse.y"
 6503|  1.74k|                    {
 6504|  1.74k|                      (yyval.nd) = (yyvsp[-1].nd);
 6505|  1.74k|                    }
 6506|  1.74k|#line 6507 "mrbgems/mruby-compiler/core/y.tab.c"
 6507|  1.74k|    break;
 6508|       |
 6509|      0|  case 5: /* top_stmts: none  */
  ------------------
  |  Branch (6509:3): [True: 0, False: 12.5M]
  ------------------
 6510|      0|#line 1643 "mrbgems/mruby-compiler/core/parse.y"
 6511|      0|                    {
 6512|      0|                      (yyval.nd) = new_begin(p, 0);
 6513|      0|                    }
 6514|      0|#line 6515 "mrbgems/mruby-compiler/core/y.tab.c"
 6515|      0|    break;
 6516|       |
 6517|  1.74k|  case 6: /* top_stmts: top_stmt  */
  ------------------
  |  Branch (6517:3): [True: 1.74k, False: 12.5M]
  ------------------
 6518|  1.74k|#line 1647 "mrbgems/mruby-compiler/core/parse.y"
 6519|  1.74k|                    {
 6520|  1.74k|                      (yyval.nd) = new_begin(p, (yyvsp[0].nd));
 6521|  1.74k|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|  1.74k|#define NODE_LINENO(c,n) do {\
  |  |  126|  1.74k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 1.74k, False: 0]
  |  |  ------------------
  |  |  127|  1.74k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  1.74k|     (c)->lineno = (n)->lineno;\
  |  |  129|  1.74k|  }\
  |  |  130|  1.74k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6522|  1.74k|                    }
 6523|  1.74k|#line 6524 "mrbgems/mruby-compiler/core/y.tab.c"
 6524|  1.74k|    break;
 6525|       |
 6526|  1.74k|  case 7: /* top_stmts: top_stmts terms top_stmt  */
  ------------------
  |  Branch (6526:3): [True: 1.74k, False: 12.5M]
  ------------------
 6527|  1.74k|#line 1652 "mrbgems/mruby-compiler/core/parse.y"
 6528|  1.74k|                    {
 6529|  1.74k|                      (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
  ------------------
  |  |  268|  1.74k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|  1.74k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 6530|  1.74k|                    }
 6531|  1.74k|#line 6532 "mrbgems/mruby-compiler/core/y.tab.c"
 6532|  1.74k|    break;
 6533|       |
 6534|      0|  case 8: /* top_stmts: error top_stmt  */
  ------------------
  |  Branch (6534:3): [True: 0, False: 12.5M]
  ------------------
 6535|      0|#line 1656 "mrbgems/mruby-compiler/core/parse.y"
 6536|      0|                    {
 6537|      0|                      (yyval.nd) = new_begin(p, 0);
 6538|      0|                    }
 6539|      0|#line 6540 "mrbgems/mruby-compiler/core/y.tab.c"
 6540|      0|    break;
 6541|       |
 6542|      0|  case 10: /* @2: %empty  */
  ------------------
  |  Branch (6542:3): [True: 0, False: 12.5M]
  ------------------
 6543|      0|#line 1663 "mrbgems/mruby-compiler/core/parse.y"
 6544|      0|                    {
 6545|      0|                      (yyval.nd) = local_switch(p);
 6546|      0|                      nvars_block(p);
 6547|      0|                    }
 6548|      0|#line 6549 "mrbgems/mruby-compiler/core/y.tab.c"
 6549|      0|    break;
 6550|       |
 6551|      0|  case 11: /* top_stmt: keyword_BEGIN @2 '{' top_compstmt '}'  */
  ------------------
  |  Branch (6551:3): [True: 0, False: 12.5M]
  ------------------
 6552|      0|#line 1668 "mrbgems/mruby-compiler/core/parse.y"
 6553|      0|                    {
 6554|      0|                      yyerror(p, "BEGIN not supported");
 6555|      0|                      local_resume(p, (yyvsp[-3].nd));
 6556|      0|                      nvars_unnest(p);
 6557|      0|                      (yyval.nd) = 0;
 6558|      0|                    }
 6559|      0|#line 6560 "mrbgems/mruby-compiler/core/y.tab.c"
 6560|      0|    break;
 6561|       |
 6562|  33.5k|  case 12: /* bodystmt: compstmt opt_rescue opt_else opt_ensure  */
  ------------------
  |  Branch (6562:3): [True: 33.5k, False: 12.5M]
  ------------------
 6563|  33.5k|#line 1680 "mrbgems/mruby-compiler/core/parse.y"
 6564|  33.5k|                    {
 6565|  33.5k|                      if ((yyvsp[-2].nd)) {
  ------------------
  |  Branch (6565:27): [True: 0, False: 33.5k]
  ------------------
 6566|      0|                        (yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
 6567|      0|                        NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6568|      0|                      }
 6569|  33.5k|                      else if ((yyvsp[-1].nd)) {
  ------------------
  |  Branch (6569:32): [True: 0, False: 33.5k]
  ------------------
 6570|      0|                        yywarning(p, "else without rescue is useless");
 6571|      0|                        (yyval.nd) = push((yyvsp[-3].nd), (yyvsp[-1].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 6572|      0|                      }
 6573|  33.5k|                      else {
 6574|  33.5k|                        (yyval.nd) = (yyvsp[-3].nd);
 6575|  33.5k|                      }
 6576|  33.5k|                      if ((yyvsp[0].nd)) {
  ------------------
  |  Branch (6576:27): [True: 0, False: 33.5k]
  ------------------
 6577|      0|                        if ((yyval.nd)) {
  ------------------
  |  Branch (6577:29): [True: 0, False: 0]
  ------------------
 6578|      0|                          (yyval.nd) = new_ensure(p, (yyval.nd), (yyvsp[0].nd));
 6579|      0|                        }
 6580|      0|                        else {
 6581|      0|                          (yyval.nd) = push((yyvsp[0].nd), new_nil(p));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 6582|      0|                        }
 6583|      0|                      }
 6584|  33.5k|                    }
 6585|  33.5k|#line 6586 "mrbgems/mruby-compiler/core/y.tab.c"
 6586|  33.5k|    break;
 6587|       |
 6588|   251k|  case 13: /* compstmt: stmts opt_terms  */
  ------------------
  |  Branch (6588:3): [True: 251k, False: 12.2M]
  ------------------
 6589|   251k|#line 1704 "mrbgems/mruby-compiler/core/parse.y"
 6590|   251k|                    {
 6591|   251k|                      (yyval.nd) = (yyvsp[-1].nd);
 6592|   251k|                    }
 6593|   251k|#line 6594 "mrbgems/mruby-compiler/core/y.tab.c"
 6594|   251k|    break;
 6595|       |
 6596|  36.0k|  case 14: /* stmts: none  */
  ------------------
  |  Branch (6596:3): [True: 36.0k, False: 12.5M]
  ------------------
 6597|  36.0k|#line 1710 "mrbgems/mruby-compiler/core/parse.y"
 6598|  36.0k|                    {
 6599|  36.0k|                      (yyval.nd) = new_begin(p, 0);
 6600|  36.0k|                    }
 6601|  36.0k|#line 6602 "mrbgems/mruby-compiler/core/y.tab.c"
 6602|  36.0k|    break;
 6603|       |
 6604|   215k|  case 15: /* stmts: stmt  */
  ------------------
  |  Branch (6604:3): [True: 215k, False: 12.3M]
  ------------------
 6605|   215k|#line 1714 "mrbgems/mruby-compiler/core/parse.y"
 6606|   215k|                    {
 6607|   215k|                      (yyval.nd) = new_begin(p, (yyvsp[0].nd));
 6608|   215k|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|   215k|#define NODE_LINENO(c,n) do {\
  |  |  126|   215k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 215k, False: 0]
  |  |  ------------------
  |  |  127|   215k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|   215k|     (c)->lineno = (n)->lineno;\
  |  |  129|   215k|  }\
  |  |  130|   215k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6609|   215k|                    }
 6610|   215k|#line 6611 "mrbgems/mruby-compiler/core/y.tab.c"
 6611|   215k|    break;
 6612|       |
 6613|   358k|  case 16: /* stmts: stmts terms stmt  */
  ------------------
  |  Branch (6613:3): [True: 358k, False: 12.1M]
  ------------------
 6614|   358k|#line 1719 "mrbgems/mruby-compiler/core/parse.y"
 6615|   358k|                    {
 6616|   358k|                      (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
  ------------------
  |  |  268|   358k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|   358k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 6617|   358k|                    }
 6618|   358k|#line 6619 "mrbgems/mruby-compiler/core/y.tab.c"
 6619|   358k|    break;
 6620|       |
 6621|      0|  case 17: /* stmts: error stmt  */
  ------------------
  |  Branch (6621:3): [True: 0, False: 12.5M]
  ------------------
 6622|      0|#line 1723 "mrbgems/mruby-compiler/core/parse.y"
 6623|      0|                    {
 6624|      0|                      (yyval.nd) = new_begin(p, (yyvsp[0].nd));
 6625|      0|                    }
 6626|      0|#line 6627 "mrbgems/mruby-compiler/core/y.tab.c"
 6627|      0|    break;
 6628|       |
 6629|      0|  case 18: /* $@3: %empty  */
  ------------------
  |  Branch (6629:3): [True: 0, False: 12.5M]
  ------------------
 6630|      0|#line 1728 "mrbgems/mruby-compiler/core/parse.y"
 6631|      0|                                     {p->lstate = EXPR_FNAME;}
 6632|      0|#line 6633 "mrbgems/mruby-compiler/core/y.tab.c"
 6633|      0|    break;
 6634|       |
 6635|      0|  case 19: /* stmt: keyword_alias fsym $@3 fsym  */
  ------------------
  |  Branch (6635:3): [True: 0, False: 12.5M]
  ------------------
 6636|      0|#line 1729 "mrbgems/mruby-compiler/core/parse.y"
 6637|      0|                    {
 6638|      0|                      (yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id));
 6639|      0|                    }
 6640|      0|#line 6641 "mrbgems/mruby-compiler/core/y.tab.c"
 6641|      0|    break;
 6642|       |
 6643|      0|  case 20: /* stmt: keyword_undef undef_list  */
  ------------------
  |  Branch (6643:3): [True: 0, False: 12.5M]
  ------------------
 6644|      0|#line 1733 "mrbgems/mruby-compiler/core/parse.y"
 6645|      0|                    {
 6646|      0|                      (yyval.nd) = (yyvsp[0].nd);
 6647|      0|                    }
 6648|      0|#line 6649 "mrbgems/mruby-compiler/core/y.tab.c"
 6649|      0|    break;
 6650|       |
 6651|      0|  case 21: /* stmt: stmt modifier_if expr_value  */
  ------------------
  |  Branch (6651:3): [True: 0, False: 12.5M]
  ------------------
 6652|      0|#line 1737 "mrbgems/mruby-compiler/core/parse.y"
 6653|      0|                    {
 6654|      0|                      (yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
 6655|      0|                    }
 6656|      0|#line 6657 "mrbgems/mruby-compiler/core/y.tab.c"
 6657|      0|    break;
 6658|       |
 6659|      0|  case 22: /* stmt: stmt modifier_unless expr_value  */
  ------------------
  |  Branch (6659:3): [True: 0, False: 12.5M]
  ------------------
 6660|      0|#line 1741 "mrbgems/mruby-compiler/core/parse.y"
 6661|      0|                    {
 6662|      0|                      (yyval.nd) = new_unless(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
 6663|      0|                    }
 6664|      0|#line 6665 "mrbgems/mruby-compiler/core/y.tab.c"
 6665|      0|    break;
 6666|       |
 6667|      0|  case 23: /* stmt: stmt modifier_while expr_value  */
  ------------------
  |  Branch (6667:3): [True: 0, False: 12.5M]
  ------------------
 6668|      0|#line 1745 "mrbgems/mruby-compiler/core/parse.y"
 6669|      0|                    {
 6670|      0|                      (yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
 6671|      0|                    }
 6672|      0|#line 6673 "mrbgems/mruby-compiler/core/y.tab.c"
 6673|      0|    break;
 6674|       |
 6675|      0|  case 24: /* stmt: stmt modifier_until expr_value  */
  ------------------
  |  Branch (6675:3): [True: 0, False: 12.5M]
  ------------------
 6676|      0|#line 1749 "mrbgems/mruby-compiler/core/parse.y"
 6677|      0|                    {
 6678|      0|                      (yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
 6679|      0|                    }
 6680|      0|#line 6681 "mrbgems/mruby-compiler/core/y.tab.c"
 6681|      0|    break;
 6682|       |
 6683|      0|  case 25: /* stmt: stmt modifier_rescue stmt  */
  ------------------
  |  Branch (6683:3): [True: 0, False: 12.5M]
  ------------------
 6684|      0|#line 1753 "mrbgems/mruby-compiler/core/parse.y"
 6685|      0|                    {
 6686|      0|                      (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6687|      0|                    }
 6688|      0|#line 6689 "mrbgems/mruby-compiler/core/y.tab.c"
 6689|      0|    break;
 6690|       |
 6691|      0|  case 26: /* stmt: keyword_END '{' compstmt '}'  */
  ------------------
  |  Branch (6691:3): [True: 0, False: 12.5M]
  ------------------
 6692|      0|#line 1757 "mrbgems/mruby-compiler/core/parse.y"
 6693|      0|                    {
 6694|      0|                      yyerror(p, "END not supported");
 6695|      0|                      (yyval.nd) = new_postexe(p, (yyvsp[-1].nd));
 6696|      0|                    }
 6697|      0|#line 6698 "mrbgems/mruby-compiler/core/y.tab.c"
 6698|      0|    break;
 6699|       |
 6700|      0|  case 28: /* stmt: mlhs '=' command_call  */
  ------------------
  |  Branch (6700:3): [True: 0, False: 12.5M]
  ------------------
 6701|      0|#line 1763 "mrbgems/mruby-compiler/core/parse.y"
 6702|      0|                    {
 6703|      0|                      (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6704|      0|                    }
 6705|      0|#line 6706 "mrbgems/mruby-compiler/core/y.tab.c"
 6706|      0|    break;
 6707|       |
 6708|      0|  case 29: /* stmt: lhs '=' mrhs  */
  ------------------
  |  Branch (6708:3): [True: 0, False: 12.5M]
  ------------------
 6709|      0|#line 1767 "mrbgems/mruby-compiler/core/parse.y"
 6710|      0|                    {
 6711|      0|                      (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
 6712|      0|                    }
 6713|      0|#line 6714 "mrbgems/mruby-compiler/core/y.tab.c"
 6714|      0|    break;
 6715|       |
 6716|      0|  case 30: /* stmt: mlhs '=' arg  */
  ------------------
  |  Branch (6716:3): [True: 0, False: 12.5M]
  ------------------
 6717|      0|#line 1771 "mrbgems/mruby-compiler/core/parse.y"
 6718|      0|                    {
 6719|      0|                      (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6720|      0|                    }
 6721|      0|#line 6722 "mrbgems/mruby-compiler/core/y.tab.c"
 6722|      0|    break;
 6723|       |
 6724|      0|  case 31: /* stmt: mlhs '=' mrhs  */
  ------------------
  |  Branch (6724:3): [True: 0, False: 12.5M]
  ------------------
 6725|      0|#line 1775 "mrbgems/mruby-compiler/core/parse.y"
 6726|      0|                    {
 6727|      0|                      (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
 6728|      0|                    }
 6729|      0|#line 6730 "mrbgems/mruby-compiler/core/y.tab.c"
 6730|      0|    break;
 6731|       |
 6732|      0|  case 32: /* stmt: arg "=>" "local variable or method"  */
  ------------------
  |  Branch (6732:3): [True: 0, False: 12.5M]
  ------------------
 6733|      0|#line 1779 "mrbgems/mruby-compiler/core/parse.y"
 6734|      0|                    {
 6735|      0|                      node *lhs = new_lvar(p, (yyvsp[0].id));
 6736|      0|                      assignable(p, lhs);
 6737|      0|                      (yyval.nd) = new_asgn(p, lhs, (yyvsp[-2].nd));
 6738|      0|                    }
 6739|      0|#line 6740 "mrbgems/mruby-compiler/core/y.tab.c"
 6740|      0|    break;
 6741|       |
 6742|      0|  case 34: /* command_asgn: lhs '=' command_rhs  */
  ------------------
  |  Branch (6742:3): [True: 0, False: 12.5M]
  ------------------
 6743|      0|#line 1788 "mrbgems/mruby-compiler/core/parse.y"
 6744|      0|                    {
 6745|      0|                      (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6746|      0|                    }
 6747|      0|#line 6748 "mrbgems/mruby-compiler/core/y.tab.c"
 6748|      0|    break;
 6749|       |
 6750|      0|  case 35: /* command_asgn: var_lhs tOP_ASGN command_rhs  */
  ------------------
  |  Branch (6750:3): [True: 0, False: 12.5M]
  ------------------
 6751|      0|#line 1792 "mrbgems/mruby-compiler/core/parse.y"
 6752|      0|                    {
 6753|      0|                      (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
 6754|      0|                    }
 6755|      0|#line 6756 "mrbgems/mruby-compiler/core/y.tab.c"
 6756|      0|    break;
 6757|       |
 6758|      0|  case 36: /* command_asgn: primary_value '[' opt_call_args ']' tOP_ASGN command_rhs  */
  ------------------
  |  Branch (6758:3): [True: 0, False: 12.5M]
  ------------------
 6759|      0|#line 1796 "mrbgems/mruby-compiler/core/parse.y"
 6760|      0|                    {
 6761|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 6762|      0|                    }
 6763|      0|#line 6764 "mrbgems/mruby-compiler/core/y.tab.c"
 6764|      0|    break;
 6765|       |
 6766|      0|  case 37: /* command_asgn: primary_value call_op "local variable or method" tOP_ASGN command_rhs  */
  ------------------
  |  Branch (6766:3): [True: 0, False: 12.5M]
  ------------------
 6767|      0|#line 1800 "mrbgems/mruby-compiler/core/parse.y"
 6768|      0|                    {
 6769|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
 6770|      0|                    }
 6771|      0|#line 6772 "mrbgems/mruby-compiler/core/y.tab.c"
 6772|      0|    break;
 6773|       |
 6774|      0|  case 38: /* command_asgn: primary_value call_op "constant" tOP_ASGN command_rhs  */
  ------------------
  |  Branch (6774:3): [True: 0, False: 12.5M]
  ------------------
 6775|      0|#line 1804 "mrbgems/mruby-compiler/core/parse.y"
 6776|      0|                    {
 6777|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
 6778|      0|                    }
 6779|      0|#line 6780 "mrbgems/mruby-compiler/core/y.tab.c"
 6780|      0|    break;
 6781|       |
 6782|      0|  case 39: /* command_asgn: primary_value "::" "constant" tOP_ASGN command_call  */
  ------------------
  |  Branch (6782:3): [True: 0, False: 12.5M]
  ------------------
 6783|      0|#line 1808 "mrbgems/mruby-compiler/core/parse.y"
 6784|      0|                    {
 6785|      0|                      yyerror(p, "constant re-assignment");
 6786|      0|                      (yyval.nd) = 0;
 6787|      0|                    }
 6788|      0|#line 6789 "mrbgems/mruby-compiler/core/y.tab.c"
 6789|      0|    break;
 6790|       |
 6791|      0|  case 40: /* command_asgn: primary_value "::" "local variable or method" tOP_ASGN command_rhs  */
  ------------------
  |  Branch (6791:3): [True: 0, False: 12.5M]
  ------------------
 6792|      0|#line 1813 "mrbgems/mruby-compiler/core/parse.y"
 6793|      0|                    {
 6794|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
 6795|      0|                    }
 6796|      0|#line 6797 "mrbgems/mruby-compiler/core/y.tab.c"
 6797|      0|    break;
 6798|       |
 6799|      0|  case 41: /* command_asgn: defn_head f_opt_arglist_paren '=' command  */
  ------------------
  |  Branch (6799:3): [True: 0, False: 12.5M]
  ------------------
 6800|      0|#line 1817 "mrbgems/mruby-compiler/core/parse.y"
 6801|      0|                    {
 6802|      0|                      (yyval.nd) = (yyvsp[-3].nd);
 6803|      0|                      endless_method_name(p, (yyvsp[-3].nd));
 6804|      0|                      void_expr_error(p, (yyvsp[0].nd));
 6805|      0|                      defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
 6806|      0|                      nvars_unnest(p);
 6807|      0|                      p->in_def--;
 6808|      0|                    }
 6809|      0|#line 6810 "mrbgems/mruby-compiler/core/y.tab.c"
 6810|      0|    break;
 6811|       |
 6812|      0|  case 42: /* command_asgn: defn_head f_opt_arglist_paren '=' command modifier_rescue arg  */
  ------------------
  |  Branch (6812:3): [True: 0, False: 12.5M]
  ------------------
 6813|      0|#line 1826 "mrbgems/mruby-compiler/core/parse.y"
 6814|      0|                    {
 6815|      0|                      (yyval.nd) = (yyvsp[-5].nd);
 6816|      0|                      endless_method_name(p, (yyvsp[-5].nd));
 6817|      0|                      void_expr_error(p, (yyvsp[-2].nd));
 6818|      0|                      defn_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
 6819|      0|                      nvars_unnest(p);
 6820|      0|                      p->in_def--;
 6821|      0|                    }
 6822|      0|#line 6823 "mrbgems/mruby-compiler/core/y.tab.c"
 6823|      0|    break;
 6824|       |
 6825|      0|  case 43: /* command_asgn: defs_head f_opt_arglist_paren '=' command  */
  ------------------
  |  Branch (6825:3): [True: 0, False: 12.5M]
  ------------------
 6826|      0|#line 1835 "mrbgems/mruby-compiler/core/parse.y"
 6827|      0|                    {
 6828|      0|                      (yyval.nd) = (yyvsp[-3].nd);
 6829|      0|                      void_expr_error(p, (yyvsp[0].nd));
 6830|      0|                      defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
 6831|      0|                      nvars_unnest(p);
 6832|      0|                      p->in_def--;
 6833|      0|                      p->in_single--;
 6834|      0|                    }
 6835|      0|#line 6836 "mrbgems/mruby-compiler/core/y.tab.c"
 6836|      0|    break;
 6837|       |
 6838|      0|  case 44: /* command_asgn: defs_head f_opt_arglist_paren '=' command modifier_rescue arg  */
  ------------------
  |  Branch (6838:3): [True: 0, False: 12.5M]
  ------------------
 6839|      0|#line 1844 "mrbgems/mruby-compiler/core/parse.y"
 6840|      0|                    {
 6841|      0|                      (yyval.nd) = (yyvsp[-5].nd);
 6842|      0|                      void_expr_error(p, (yyvsp[-2].nd));
 6843|      0|                      defs_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
 6844|      0|                      nvars_unnest(p);
 6845|      0|                      p->in_def--;
 6846|      0|                      p->in_single--;
 6847|      0|                    }
 6848|      0|#line 6849 "mrbgems/mruby-compiler/core/y.tab.c"
 6849|      0|    break;
 6850|       |
 6851|      0|  case 45: /* command_asgn: backref tOP_ASGN command_rhs  */
  ------------------
  |  Branch (6851:3): [True: 0, False: 12.5M]
  ------------------
 6852|      0|#line 1853 "mrbgems/mruby-compiler/core/parse.y"
 6853|      0|                    {
 6854|      0|                      backref_error(p, (yyvsp[-2].nd));
 6855|      0|                      (yyval.nd) = new_begin(p, 0);
 6856|      0|                    }
 6857|      0|#line 6858 "mrbgems/mruby-compiler/core/y.tab.c"
 6858|      0|    break;
 6859|       |
 6860|      0|  case 47: /* command_rhs: command_call modifier_rescue stmt  */
  ------------------
  |  Branch (6860:3): [True: 0, False: 12.5M]
  ------------------
 6861|      0|#line 1861 "mrbgems/mruby-compiler/core/parse.y"
 6862|      0|                    {
 6863|      0|                      (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6864|      0|                    }
 6865|      0|#line 6866 "mrbgems/mruby-compiler/core/y.tab.c"
 6866|      0|    break;
 6867|       |
 6868|  4.11k|  case 50: /* expr: expr keyword_and expr  */
  ------------------
  |  Branch (6868:3): [True: 4.11k, False: 12.5M]
  ------------------
 6869|  4.11k|#line 1870 "mrbgems/mruby-compiler/core/parse.y"
 6870|  4.11k|                    {
 6871|  4.11k|                      (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6872|  4.11k|                    }
 6873|  4.11k|#line 6874 "mrbgems/mruby-compiler/core/y.tab.c"
 6874|  4.11k|    break;
 6875|       |
 6876|  2.09k|  case 51: /* expr: expr keyword_or expr  */
  ------------------
  |  Branch (6876:3): [True: 2.09k, False: 12.5M]
  ------------------
 6877|  2.09k|#line 1874 "mrbgems/mruby-compiler/core/parse.y"
 6878|  2.09k|                    {
 6879|  2.09k|                      (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 6880|  2.09k|                    }
 6881|  2.09k|#line 6882 "mrbgems/mruby-compiler/core/y.tab.c"
 6882|  2.09k|    break;
 6883|       |
 6884|      0|  case 52: /* expr: keyword_not opt_nl expr  */
  ------------------
  |  Branch (6884:3): [True: 0, False: 12.5M]
  ------------------
 6885|      0|#line 1878 "mrbgems/mruby-compiler/core/parse.y"
 6886|      0|                    {
 6887|      0|                      (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
 6888|      0|                    }
 6889|      0|#line 6890 "mrbgems/mruby-compiler/core/y.tab.c"
 6890|      0|    break;
 6891|       |
 6892|      0|  case 53: /* expr: '!' command_call  */
  ------------------
  |  Branch (6892:3): [True: 0, False: 12.5M]
  ------------------
 6893|      0|#line 1882 "mrbgems/mruby-compiler/core/parse.y"
 6894|      0|                    {
 6895|      0|                      (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
 6896|      0|                    }
 6897|      0|#line 6898 "mrbgems/mruby-compiler/core/y.tab.c"
 6898|      0|    break;
 6899|       |
 6900|  1.74k|  case 55: /* defn_head: keyword_def fname  */
  ------------------
  |  Branch (6900:3): [True: 1.74k, False: 12.5M]
  ------------------
 6901|  1.74k|#line 1890 "mrbgems/mruby-compiler/core/parse.y"
 6902|  1.74k|                    {
 6903|  1.74k|                      (yyval.nd) = new_def(p, (yyvsp[0].id), nint(p->cmdarg_stack), local_switch(p));
  ------------------
  |  |  134|  1.74k|#define nint(x) ((node*)(intptr_t)(x))
  ------------------
 6904|  1.74k|                      p->cmdarg_stack = 0;
 6905|  1.74k|                      p->in_def++;
 6906|  1.74k|                      nvars_block(p);
 6907|  1.74k|                    }
 6908|  1.74k|#line 6909 "mrbgems/mruby-compiler/core/y.tab.c"
 6909|  1.74k|    break;
 6910|       |
 6911|      0|  case 56: /* $@4: %empty  */
  ------------------
  |  Branch (6911:3): [True: 0, False: 12.5M]
  ------------------
 6912|      0|#line 1899 "mrbgems/mruby-compiler/core/parse.y"
 6913|      0|                    {
 6914|      0|                      p->lstate = EXPR_FNAME;
 6915|      0|                    }
 6916|      0|#line 6917 "mrbgems/mruby-compiler/core/y.tab.c"
 6917|      0|    break;
 6918|       |
 6919|      0|  case 57: /* defs_head: keyword_def singleton dot_or_colon $@4 fname  */
  ------------------
  |  Branch (6919:3): [True: 0, False: 12.5M]
  ------------------
 6920|      0|#line 1903 "mrbgems/mruby-compiler/core/parse.y"
 6921|      0|                    {
 6922|      0|                      (yyval.nd) = new_sdef(p, (yyvsp[-3].nd), (yyvsp[0].id), nint(p->cmdarg_stack), local_switch(p));
  ------------------
  |  |  134|      0|#define nint(x) ((node*)(intptr_t)(x))
  ------------------
 6923|      0|                      p->cmdarg_stack = 0;
 6924|      0|                      p->in_def++;
 6925|      0|                      p->in_single++;
 6926|      0|                      nvars_block(p);
 6927|      0|                      p->lstate = EXPR_ENDFN; /* force for args */
 6928|      0|                    }
 6929|      0|#line 6930 "mrbgems/mruby-compiler/core/y.tab.c"
 6930|      0|    break;
 6931|       |
 6932|  17.5k|  case 58: /* expr_value: expr  */
  ------------------
  |  Branch (6932:3): [True: 17.5k, False: 12.5M]
  ------------------
 6933|  17.5k|#line 1914 "mrbgems/mruby-compiler/core/parse.y"
 6934|  17.5k|                    {
 6935|  17.5k|                      if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p);
  ------------------
  |  Branch (6935:27): [True: 0, False: 17.5k]
  ------------------
 6936|  17.5k|                      else {
 6937|  17.5k|                        (yyval.nd) = (yyvsp[0].nd);
 6938|  17.5k|                      }
 6939|  17.5k|                    }
 6940|  17.5k|#line 6941 "mrbgems/mruby-compiler/core/y.tab.c"
 6941|  17.5k|    break;
 6942|       |
 6943|      0|  case 62: /* block_command: block_call call_op2 operation2 command_args  */
  ------------------
  |  Branch (6943:3): [True: 0, False: 12.5M]
  ------------------
 6944|      0|#line 1928 "mrbgems/mruby-compiler/core/parse.y"
 6945|      0|                    {
 6946|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
 6947|      0|                    }
 6948|      0|#line 6949 "mrbgems/mruby-compiler/core/y.tab.c"
 6949|      0|    break;
 6950|       |
 6951|      0|  case 63: /* $@5: %empty  */
  ------------------
  |  Branch (6951:3): [True: 0, False: 12.5M]
  ------------------
 6952|      0|#line 1934 "mrbgems/mruby-compiler/core/parse.y"
 6953|      0|                    {
 6954|      0|                      local_nest(p);
 6955|      0|                      nvars_nest(p);
 6956|      0|                    }
 6957|      0|#line 6958 "mrbgems/mruby-compiler/core/y.tab.c"
 6958|      0|    break;
 6959|       |
 6960|      0|  case 64: /* cmd_brace_block: "{" $@5 opt_block_param compstmt '}'  */
  ------------------
  |  Branch (6960:3): [True: 0, False: 12.5M]
  ------------------
 6961|      0|#line 1941 "mrbgems/mruby-compiler/core/parse.y"
 6962|      0|                    {
 6963|      0|                      (yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd));
 6964|      0|                      local_unnest(p);
 6965|      0|                      nvars_unnest(p);
 6966|      0|                    }
 6967|      0|#line 6968 "mrbgems/mruby-compiler/core/y.tab.c"
 6968|      0|    break;
 6969|       |
 6970|      0|  case 65: /* command: operation command_args  */
  ------------------
  |  Branch (6970:3): [True: 0, False: 12.5M]
  ------------------
 6971|      0|#line 1949 "mrbgems/mruby-compiler/core/parse.y"
 6972|      0|                    {
 6973|      0|                      (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
 6974|      0|                    }
 6975|      0|#line 6976 "mrbgems/mruby-compiler/core/y.tab.c"
 6976|      0|    break;
 6977|       |
 6978|      0|  case 66: /* command: operation command_args cmd_brace_block  */
  ------------------
  |  Branch (6978:3): [True: 0, False: 12.5M]
  ------------------
 6979|      0|#line 1953 "mrbgems/mruby-compiler/core/parse.y"
 6980|      0|                    {
 6981|      0|                      args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 6982|      0|                      (yyval.nd) = new_fcall(p, (yyvsp[-2].id), (yyvsp[-1].nd));
 6983|      0|                    }
 6984|      0|#line 6985 "mrbgems/mruby-compiler/core/y.tab.c"
 6985|      0|    break;
 6986|       |
 6987|      0|  case 67: /* command: primary_value call_op operation2 command_args  */
  ------------------
  |  Branch (6987:3): [True: 0, False: 12.5M]
  ------------------
 6988|      0|#line 1958 "mrbgems/mruby-compiler/core/parse.y"
 6989|      0|                    {
 6990|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
 6991|      0|                    }
 6992|      0|#line 6993 "mrbgems/mruby-compiler/core/y.tab.c"
 6993|      0|    break;
 6994|       |
 6995|      0|  case 68: /* command: primary_value call_op operation2 command_args cmd_brace_block  */
  ------------------
  |  Branch (6995:3): [True: 0, False: 12.5M]
  ------------------
 6996|      0|#line 1962 "mrbgems/mruby-compiler/core/parse.y"
 6997|      0|                    {
 6998|      0|                      args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 6999|      0|                      (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
 7000|      0|                   }
 7001|      0|#line 7002 "mrbgems/mruby-compiler/core/y.tab.c"
 7002|      0|    break;
 7003|       |
 7004|      0|  case 69: /* command: primary_value "::" operation2 command_args  */
  ------------------
  |  Branch (7004:3): [True: 0, False: 12.5M]
  ------------------
 7005|      0|#line 1967 "mrbgems/mruby-compiler/core/parse.y"
 7006|      0|                    {
 7007|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
 7008|      0|                    }
 7009|      0|#line 7010 "mrbgems/mruby-compiler/core/y.tab.c"
 7010|      0|    break;
 7011|       |
 7012|      0|  case 70: /* command: primary_value "::" operation2 command_args cmd_brace_block  */
  ------------------
  |  Branch (7012:3): [True: 0, False: 12.5M]
  ------------------
 7013|      0|#line 1971 "mrbgems/mruby-compiler/core/parse.y"
 7014|      0|                    {
 7015|      0|                      args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 7016|      0|                      (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), tCOLON2);
 7017|      0|                    }
 7018|      0|#line 7019 "mrbgems/mruby-compiler/core/y.tab.c"
 7019|      0|    break;
 7020|       |
 7021|      0|  case 71: /* command: keyword_super command_args  */
  ------------------
  |  Branch (7021:3): [True: 0, False: 12.5M]
  ------------------
 7022|      0|#line 1976 "mrbgems/mruby-compiler/core/parse.y"
 7023|      0|                    {
 7024|      0|                      (yyval.nd) = new_super(p, (yyvsp[0].nd));
 7025|      0|                    }
 7026|      0|#line 7027 "mrbgems/mruby-compiler/core/y.tab.c"
 7027|      0|    break;
 7028|       |
 7029|      0|  case 72: /* command: keyword_yield command_args  */
  ------------------
  |  Branch (7029:3): [True: 0, False: 12.5M]
  ------------------
 7030|      0|#line 1980 "mrbgems/mruby-compiler/core/parse.y"
 7031|      0|                    {
 7032|      0|                      (yyval.nd) = new_yield(p, (yyvsp[0].nd));
 7033|      0|                    }
 7034|      0|#line 7035 "mrbgems/mruby-compiler/core/y.tab.c"
 7035|      0|    break;
 7036|       |
 7037|      0|  case 73: /* command: keyword_return call_args  */
  ------------------
  |  Branch (7037:3): [True: 0, False: 12.5M]
  ------------------
 7038|      0|#line 1984 "mrbgems/mruby-compiler/core/parse.y"
 7039|      0|                    {
 7040|      0|                      (yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd)));
 7041|      0|                    }
 7042|      0|#line 7043 "mrbgems/mruby-compiler/core/y.tab.c"
 7043|      0|    break;
 7044|       |
 7045|      0|  case 74: /* command: keyword_break call_args  */
  ------------------
  |  Branch (7045:3): [True: 0, False: 12.5M]
  ------------------
 7046|      0|#line 1988 "mrbgems/mruby-compiler/core/parse.y"
 7047|      0|                    {
 7048|      0|                      (yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd)));
 7049|      0|                    }
 7050|      0|#line 7051 "mrbgems/mruby-compiler/core/y.tab.c"
 7051|      0|    break;
 7052|       |
 7053|      0|  case 75: /* command: keyword_next call_args  */
  ------------------
  |  Branch (7053:3): [True: 0, False: 12.5M]
  ------------------
 7054|      0|#line 1992 "mrbgems/mruby-compiler/core/parse.y"
 7055|      0|                    {
 7056|      0|                      (yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd)));
 7057|      0|                    }
 7058|      0|#line 7059 "mrbgems/mruby-compiler/core/y.tab.c"
 7059|      0|    break;
 7060|       |
 7061|      0|  case 76: /* mlhs: mlhs_basic  */
  ------------------
  |  Branch (7061:3): [True: 0, False: 12.5M]
  ------------------
 7062|      0|#line 1998 "mrbgems/mruby-compiler/core/parse.y"
 7063|      0|                    {
 7064|      0|                      (yyval.nd) = (yyvsp[0].nd);
 7065|      0|                    }
 7066|      0|#line 7067 "mrbgems/mruby-compiler/core/y.tab.c"
 7067|      0|    break;
 7068|       |
 7069|      0|  case 77: /* mlhs: tLPAREN mlhs_inner rparen  */
  ------------------
  |  Branch (7069:3): [True: 0, False: 12.5M]
  ------------------
 7070|      0|#line 2002 "mrbgems/mruby-compiler/core/parse.y"
 7071|      0|                    {
 7072|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 7073|      0|                    }
 7074|      0|#line 7075 "mrbgems/mruby-compiler/core/y.tab.c"
 7075|      0|    break;
 7076|       |
 7077|      0|  case 79: /* mlhs_inner: tLPAREN mlhs_inner rparen  */
  ------------------
  |  Branch (7077:3): [True: 0, False: 12.5M]
  ------------------
 7078|      0|#line 2009 "mrbgems/mruby-compiler/core/parse.y"
 7079|      0|                    {
 7080|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 7081|      0|                    }
 7082|      0|#line 7083 "mrbgems/mruby-compiler/core/y.tab.c"
 7083|      0|    break;
 7084|       |
 7085|      0|  case 80: /* mlhs_basic: mlhs_list  */
  ------------------
  |  Branch (7085:3): [True: 0, False: 12.5M]
  ------------------
 7086|      0|#line 2015 "mrbgems/mruby-compiler/core/parse.y"
 7087|      0|                    {
 7088|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 7089|      0|                    }
 7090|      0|#line 7091 "mrbgems/mruby-compiler/core/y.tab.c"
 7091|      0|    break;
 7092|       |
 7093|      0|  case 81: /* mlhs_basic: mlhs_list mlhs_item  */
  ------------------
  |  Branch (7093:3): [True: 0, False: 12.5M]
  ------------------
 7094|      0|#line 2019 "mrbgems/mruby-compiler/core/parse.y"
 7095|      0|                    {
 7096|      0|                      (yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 7097|      0|                    }
 7098|      0|#line 7099 "mrbgems/mruby-compiler/core/y.tab.c"
 7099|      0|    break;
 7100|       |
 7101|      0|  case 82: /* mlhs_basic: mlhs_list "*" mlhs_node  */
  ------------------
  |  Branch (7101:3): [True: 0, False: 12.5M]
  ------------------
 7102|      0|#line 2023 "mrbgems/mruby-compiler/core/parse.y"
 7103|      0|                    {
 7104|      0|                      (yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  224|      0|#define list2(a,b) list2_gen(p, (a),(b))
  ------------------
 7105|      0|                    }
 7106|      0|#line 7107 "mrbgems/mruby-compiler/core/y.tab.c"
 7107|      0|    break;
 7108|       |
 7109|      0|  case 83: /* mlhs_basic: mlhs_list "*" mlhs_node ',' mlhs_post  */
  ------------------
  |  Branch (7109:3): [True: 0, False: 12.5M]
  ------------------
 7110|      0|#line 2027 "mrbgems/mruby-compiler/core/parse.y"
 7111|      0|                    {
 7112|      0|                      (yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 7113|      0|                    }
 7114|      0|#line 7115 "mrbgems/mruby-compiler/core/y.tab.c"
 7115|      0|    break;
 7116|       |
 7117|      0|  case 84: /* mlhs_basic: mlhs_list "*"  */
  ------------------
  |  Branch (7117:3): [True: 0, False: 12.5M]
  ------------------
 7118|      0|#line 2031 "mrbgems/mruby-compiler/core/parse.y"
 7119|      0|                    {
 7120|      0|                      (yyval.nd) = list2((yyvsp[-1].nd), new_nil(p));
  ------------------
  |  |  224|      0|#define list2(a,b) list2_gen(p, (a),(b))
  ------------------
 7121|      0|                    }
 7122|      0|#line 7123 "mrbgems/mruby-compiler/core/y.tab.c"
 7123|      0|    break;
 7124|       |
 7125|      0|  case 85: /* mlhs_basic: mlhs_list "*" ',' mlhs_post  */
  ------------------
  |  Branch (7125:3): [True: 0, False: 12.5M]
  ------------------
 7126|      0|#line 2035 "mrbgems/mruby-compiler/core/parse.y"
 7127|      0|                    {
 7128|      0|                      (yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 7129|      0|                    }
 7130|      0|#line 7131 "mrbgems/mruby-compiler/core/y.tab.c"
 7131|      0|    break;
 7132|       |
 7133|      0|  case 86: /* mlhs_basic: "*" mlhs_node  */
  ------------------
  |  Branch (7133:3): [True: 0, False: 12.5M]
  ------------------
 7134|      0|#line 2039 "mrbgems/mruby-compiler/core/parse.y"
 7135|      0|                    {
 7136|      0|                      (yyval.nd) = list2(0, (yyvsp[0].nd));
  ------------------
  |  |  224|      0|#define list2(a,b) list2_gen(p, (a),(b))
  ------------------
 7137|      0|                    }
 7138|      0|#line 7139 "mrbgems/mruby-compiler/core/y.tab.c"
 7139|      0|    break;
 7140|       |
 7141|      0|  case 87: /* mlhs_basic: "*" mlhs_node ',' mlhs_post  */
  ------------------
  |  Branch (7141:3): [True: 0, False: 12.5M]
  ------------------
 7142|      0|#line 2043 "mrbgems/mruby-compiler/core/parse.y"
 7143|      0|                    {
 7144|      0|                      (yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 7145|      0|                    }
 7146|      0|#line 7147 "mrbgems/mruby-compiler/core/y.tab.c"
 7147|      0|    break;
 7148|       |
 7149|      0|  case 88: /* mlhs_basic: "*"  */
  ------------------
  |  Branch (7149:3): [True: 0, False: 12.5M]
  ------------------
 7150|      0|#line 2047 "mrbgems/mruby-compiler/core/parse.y"
 7151|      0|                    {
 7152|      0|                      (yyval.nd) = list2(0, new_nil(p));
  ------------------
  |  |  224|      0|#define list2(a,b) list2_gen(p, (a),(b))
  ------------------
 7153|      0|                    }
 7154|      0|#line 7155 "mrbgems/mruby-compiler/core/y.tab.c"
 7155|      0|    break;
 7156|       |
 7157|      0|  case 89: /* mlhs_basic: "*" ',' mlhs_post  */
  ------------------
  |  Branch (7157:3): [True: 0, False: 12.5M]
  ------------------
 7158|      0|#line 2051 "mrbgems/mruby-compiler/core/parse.y"
 7159|      0|                    {
 7160|      0|                      (yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 7161|      0|                    }
 7162|      0|#line 7163 "mrbgems/mruby-compiler/core/y.tab.c"
 7163|      0|    break;
 7164|       |
 7165|      0|  case 91: /* mlhs_item: tLPAREN mlhs_inner rparen  */
  ------------------
  |  Branch (7165:3): [True: 0, False: 12.5M]
  ------------------
 7166|      0|#line 2058 "mrbgems/mruby-compiler/core/parse.y"
 7167|      0|                    {
 7168|      0|                      (yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL);
 7169|      0|                    }
 7170|      0|#line 7171 "mrbgems/mruby-compiler/core/y.tab.c"
 7171|      0|    break;
 7172|       |
 7173|      0|  case 92: /* mlhs_list: mlhs_item ','  */
  ------------------
  |  Branch (7173:3): [True: 0, False: 12.5M]
  ------------------
 7174|      0|#line 2064 "mrbgems/mruby-compiler/core/parse.y"
 7175|      0|                    {
 7176|      0|                      (yyval.nd) = list1((yyvsp[-1].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 7177|      0|                    }
 7178|      0|#line 7179 "mrbgems/mruby-compiler/core/y.tab.c"
 7179|      0|    break;
 7180|       |
 7181|      0|  case 93: /* mlhs_list: mlhs_list mlhs_item ','  */
  ------------------
  |  Branch (7181:3): [True: 0, False: 12.5M]
  ------------------
 7182|      0|#line 2068 "mrbgems/mruby-compiler/core/parse.y"
 7183|      0|                    {
 7184|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 7185|      0|                    }
 7186|      0|#line 7187 "mrbgems/mruby-compiler/core/y.tab.c"
 7187|      0|    break;
 7188|       |
 7189|      0|  case 94: /* mlhs_post: mlhs_item  */
  ------------------
  |  Branch (7189:3): [True: 0, False: 12.5M]
  ------------------
 7190|      0|#line 2074 "mrbgems/mruby-compiler/core/parse.y"
 7191|      0|                    {
 7192|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 7193|      0|                    }
 7194|      0|#line 7195 "mrbgems/mruby-compiler/core/y.tab.c"
 7195|      0|    break;
 7196|       |
 7197|      0|  case 95: /* mlhs_post: mlhs_list mlhs_item  */
  ------------------
  |  Branch (7197:3): [True: 0, False: 12.5M]
  ------------------
 7198|      0|#line 2078 "mrbgems/mruby-compiler/core/parse.y"
 7199|      0|                    {
 7200|      0|                      (yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 7201|      0|                    }
 7202|      0|#line 7203 "mrbgems/mruby-compiler/core/y.tab.c"
 7203|      0|    break;
 7204|       |
 7205|      0|  case 96: /* mlhs_node: variable  */
  ------------------
  |  Branch (7205:3): [True: 0, False: 12.5M]
  ------------------
 7206|      0|#line 2084 "mrbgems/mruby-compiler/core/parse.y"
 7207|      0|                    {
 7208|      0|                      assignable(p, (yyvsp[0].nd));
 7209|      0|                    }
 7210|      0|#line 7211 "mrbgems/mruby-compiler/core/y.tab.c"
 7211|      0|    break;
 7212|       |
 7213|      0|  case 97: /* mlhs_node: primary_value '[' opt_call_args ']'  */
  ------------------
  |  Branch (7213:3): [True: 0, False: 12.5M]
  ------------------
 7214|      0|#line 2088 "mrbgems/mruby-compiler/core/parse.y"
 7215|      0|                    {
 7216|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.');
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7217|      0|                    }
 7218|      0|#line 7219 "mrbgems/mruby-compiler/core/y.tab.c"
 7219|      0|    break;
 7220|       |
 7221|      0|  case 98: /* mlhs_node: primary_value call_op "local variable or method"  */
  ------------------
  |  Branch (7221:3): [True: 0, False: 12.5M]
  ------------------
 7222|      0|#line 2092 "mrbgems/mruby-compiler/core/parse.y"
 7223|      0|                    {
 7224|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
 7225|      0|                    }
 7226|      0|#line 7227 "mrbgems/mruby-compiler/core/y.tab.c"
 7227|      0|    break;
 7228|       |
 7229|      0|  case 99: /* mlhs_node: primary_value "::" "local variable or method"  */
  ------------------
  |  Branch (7229:3): [True: 0, False: 12.5M]
  ------------------
 7230|      0|#line 2096 "mrbgems/mruby-compiler/core/parse.y"
 7231|      0|                    {
 7232|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
 7233|      0|                    }
 7234|      0|#line 7235 "mrbgems/mruby-compiler/core/y.tab.c"
 7235|      0|    break;
 7236|       |
 7237|      0|  case 100: /* mlhs_node: primary_value call_op "constant"  */
  ------------------
  |  Branch (7237:3): [True: 0, False: 12.5M]
  ------------------
 7238|      0|#line 2100 "mrbgems/mruby-compiler/core/parse.y"
 7239|      0|                    {
 7240|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
 7241|      0|                    }
 7242|      0|#line 7243 "mrbgems/mruby-compiler/core/y.tab.c"
 7243|      0|    break;
 7244|       |
 7245|      0|  case 101: /* mlhs_node: primary_value "::" "constant"  */
  ------------------
  |  Branch (7245:3): [True: 0, False: 12.5M]
  ------------------
 7246|      0|#line 2104 "mrbgems/mruby-compiler/core/parse.y"
 7247|      0|                    {
 7248|      0|                      if (p->in_def || p->in_single)
  ------------------
  |  Branch (7248:27): [True: 0, False: 0]
  |  Branch (7248:40): [True: 0, False: 0]
  ------------------
 7249|      0|                        yyerror(p, "dynamic constant assignment");
 7250|      0|                      (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
 7251|      0|                    }
 7252|      0|#line 7253 "mrbgems/mruby-compiler/core/y.tab.c"
 7253|      0|    break;
 7254|       |
 7255|      0|  case 102: /* mlhs_node: tCOLON3 "constant"  */
  ------------------
  |  Branch (7255:3): [True: 0, False: 12.5M]
  ------------------
 7256|      0|#line 2110 "mrbgems/mruby-compiler/core/parse.y"
 7257|      0|                    {
 7258|      0|                      if (p->in_def || p->in_single)
  ------------------
  |  Branch (7258:27): [True: 0, False: 0]
  |  Branch (7258:40): [True: 0, False: 0]
  ------------------
 7259|      0|                        yyerror(p, "dynamic constant assignment");
 7260|      0|                      (yyval.nd) = new_colon3(p, (yyvsp[0].id));
 7261|      0|                    }
 7262|      0|#line 7263 "mrbgems/mruby-compiler/core/y.tab.c"
 7263|      0|    break;
 7264|       |
 7265|      0|  case 103: /* mlhs_node: backref  */
  ------------------
  |  Branch (7265:3): [True: 0, False: 12.5M]
  ------------------
 7266|      0|#line 2116 "mrbgems/mruby-compiler/core/parse.y"
 7267|      0|                    {
 7268|      0|                      backref_error(p, (yyvsp[0].nd));
 7269|      0|                      (yyval.nd) = 0;
 7270|      0|                    }
 7271|      0|#line 7272 "mrbgems/mruby-compiler/core/y.tab.c"
 7272|      0|    break;
 7273|       |
 7274|   214k|  case 104: /* lhs: variable  */
  ------------------
  |  Branch (7274:3): [True: 214k, False: 12.3M]
  ------------------
 7275|   214k|#line 2123 "mrbgems/mruby-compiler/core/parse.y"
 7276|   214k|                    {
 7277|   214k|                      assignable(p, (yyvsp[0].nd));
 7278|   214k|                    }
 7279|   214k|#line 7280 "mrbgems/mruby-compiler/core/y.tab.c"
 7280|   214k|    break;
 7281|       |
 7282|      0|  case 105: /* lhs: primary_value '[' opt_call_args ']'  */
  ------------------
  |  Branch (7282:3): [True: 0, False: 12.5M]
  ------------------
 7283|      0|#line 2127 "mrbgems/mruby-compiler/core/parse.y"
 7284|      0|                    {
 7285|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.');
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7286|      0|                    }
 7287|      0|#line 7288 "mrbgems/mruby-compiler/core/y.tab.c"
 7288|      0|    break;
 7289|       |
 7290|      0|  case 106: /* lhs: primary_value call_op "local variable or method"  */
  ------------------
  |  Branch (7290:3): [True: 0, False: 12.5M]
  ------------------
 7291|      0|#line 2131 "mrbgems/mruby-compiler/core/parse.y"
 7292|      0|                    {
 7293|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
 7294|      0|                    }
 7295|      0|#line 7296 "mrbgems/mruby-compiler/core/y.tab.c"
 7296|      0|    break;
 7297|       |
 7298|      0|  case 107: /* lhs: primary_value "::" "local variable or method"  */
  ------------------
  |  Branch (7298:3): [True: 0, False: 12.5M]
  ------------------
 7299|      0|#line 2135 "mrbgems/mruby-compiler/core/parse.y"
 7300|      0|                    {
 7301|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
 7302|      0|                    }
 7303|      0|#line 7304 "mrbgems/mruby-compiler/core/y.tab.c"
 7304|      0|    break;
 7305|       |
 7306|      0|  case 108: /* lhs: primary_value call_op "constant"  */
  ------------------
  |  Branch (7306:3): [True: 0, False: 12.5M]
  ------------------
 7307|      0|#line 2139 "mrbgems/mruby-compiler/core/parse.y"
 7308|      0|                    {
 7309|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
 7310|      0|                    }
 7311|      0|#line 7312 "mrbgems/mruby-compiler/core/y.tab.c"
 7312|      0|    break;
 7313|       |
 7314|      0|  case 109: /* lhs: primary_value "::" "constant"  */
  ------------------
  |  Branch (7314:3): [True: 0, False: 12.5M]
  ------------------
 7315|      0|#line 2143 "mrbgems/mruby-compiler/core/parse.y"
 7316|      0|                    {
 7317|      0|                      if (p->in_def || p->in_single)
  ------------------
  |  Branch (7317:27): [True: 0, False: 0]
  |  Branch (7317:40): [True: 0, False: 0]
  ------------------
 7318|      0|                        yyerror(p, "dynamic constant assignment");
 7319|      0|                      (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
 7320|      0|                    }
 7321|      0|#line 7322 "mrbgems/mruby-compiler/core/y.tab.c"
 7322|      0|    break;
 7323|       |
 7324|      0|  case 110: /* lhs: tCOLON3 "constant"  */
  ------------------
  |  Branch (7324:3): [True: 0, False: 12.5M]
  ------------------
 7325|      0|#line 2149 "mrbgems/mruby-compiler/core/parse.y"
 7326|      0|                    {
 7327|      0|                      if (p->in_def || p->in_single)
  ------------------
  |  Branch (7327:27): [True: 0, False: 0]
  |  Branch (7327:40): [True: 0, False: 0]
  ------------------
 7328|      0|                        yyerror(p, "dynamic constant assignment");
 7329|      0|                      (yyval.nd) = new_colon3(p, (yyvsp[0].id));
 7330|      0|                    }
 7331|      0|#line 7332 "mrbgems/mruby-compiler/core/y.tab.c"
 7332|      0|    break;
 7333|       |
 7334|      0|  case 111: /* lhs: backref  */
  ------------------
  |  Branch (7334:3): [True: 0, False: 12.5M]
  ------------------
 7335|      0|#line 2155 "mrbgems/mruby-compiler/core/parse.y"
 7336|      0|                    {
 7337|      0|                      backref_error(p, (yyvsp[0].nd));
 7338|      0|                      (yyval.nd) = 0;
 7339|      0|                    }
 7340|      0|#line 7341 "mrbgems/mruby-compiler/core/y.tab.c"
 7341|      0|    break;
 7342|       |
 7343|      0|  case 112: /* lhs: "numbered parameter"  */
  ------------------
  |  Branch (7343:3): [True: 0, False: 12.5M]
  ------------------
 7344|      0|#line 2160 "mrbgems/mruby-compiler/core/parse.y"
 7345|      0|                    {
 7346|      0|                      yyerror(p, "can't assign to numbered parameter");
 7347|      0|                    }
 7348|      0|#line 7349 "mrbgems/mruby-compiler/core/y.tab.c"
 7349|      0|    break;
 7350|       |
 7351|      0|  case 113: /* cname: "local variable or method"  */
  ------------------
  |  Branch (7351:3): [True: 0, False: 12.5M]
  ------------------
 7352|      0|#line 2166 "mrbgems/mruby-compiler/core/parse.y"
 7353|      0|                    {
 7354|      0|                      yyerror(p, "class/module name must be CONSTANT");
 7355|      0|                    }
 7356|      0|#line 7357 "mrbgems/mruby-compiler/core/y.tab.c"
 7357|      0|    break;
 7358|       |
 7359|      0|  case 115: /* cpath: tCOLON3 cname  */
  ------------------
  |  Branch (7359:3): [True: 0, False: 12.5M]
  ------------------
 7360|      0|#line 2173 "mrbgems/mruby-compiler/core/parse.y"
 7361|      0|                    {
 7362|      0|                      (yyval.nd) = cons(nint(1), nsym((yyvsp[0].id)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 7363|      0|                    }
 7364|      0|#line 7365 "mrbgems/mruby-compiler/core/y.tab.c"
 7365|      0|    break;
 7366|       |
 7367|      0|  case 116: /* cpath: cname  */
  ------------------
  |  Branch (7367:3): [True: 0, False: 12.5M]
  ------------------
 7368|      0|#line 2177 "mrbgems/mruby-compiler/core/parse.y"
 7369|      0|                    {
 7370|      0|                      (yyval.nd) = cons(nint(0), nsym((yyvsp[0].id)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 7371|      0|                    }
 7372|      0|#line 7373 "mrbgems/mruby-compiler/core/y.tab.c"
 7373|      0|    break;
 7374|       |
 7375|      0|  case 117: /* cpath: primary_value "::" cname  */
  ------------------
  |  Branch (7375:3): [True: 0, False: 12.5M]
  ------------------
 7376|      0|#line 2181 "mrbgems/mruby-compiler/core/parse.y"
 7377|      0|                    {
 7378|      0|                      void_expr_error(p, (yyvsp[-2].nd));
 7379|      0|                      (yyval.nd) = cons((yyvsp[-2].nd), nsym((yyvsp[0].id)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 7380|      0|                    }
 7381|      0|#line 7382 "mrbgems/mruby-compiler/core/y.tab.c"
 7382|      0|    break;
 7383|       |
 7384|      0|  case 121: /* fname: op  */
  ------------------
  |  Branch (7384:3): [True: 0, False: 12.5M]
  ------------------
 7385|      0|#line 2191 "mrbgems/mruby-compiler/core/parse.y"
 7386|      0|                    {
 7387|      0|                      p->lstate = EXPR_ENDFN;
 7388|      0|                      (yyval.id) = (yyvsp[0].id);
 7389|      0|                    }
 7390|      0|#line 7391 "mrbgems/mruby-compiler/core/y.tab.c"
 7391|      0|    break;
 7392|       |
 7393|      0|  case 122: /* fname: reswords  */
  ------------------
  |  Branch (7393:3): [True: 0, False: 12.5M]
  ------------------
 7394|      0|#line 2196 "mrbgems/mruby-compiler/core/parse.y"
 7395|      0|                    {
 7396|      0|                      p->lstate = EXPR_ENDFN;
 7397|      0|                      (yyval.id) = (yyvsp[0].id);
 7398|      0|                    }
 7399|      0|#line 7400 "mrbgems/mruby-compiler/core/y.tab.c"
 7400|      0|    break;
 7401|       |
 7402|      0|  case 125: /* undef_list: fsym  */
  ------------------
  |  Branch (7402:3): [True: 0, False: 12.5M]
  ------------------
 7403|      0|#line 2207 "mrbgems/mruby-compiler/core/parse.y"
 7404|      0|                    {
 7405|      0|                      (yyval.nd) = new_undef(p, (yyvsp[0].id));
 7406|      0|                    }
 7407|      0|#line 7408 "mrbgems/mruby-compiler/core/y.tab.c"
 7408|      0|    break;
 7409|       |
 7410|      0|  case 126: /* $@6: %empty  */
  ------------------
  |  Branch (7410:3): [True: 0, False: 12.5M]
  ------------------
 7411|      0|#line 2210 "mrbgems/mruby-compiler/core/parse.y"
 7412|      0|                                 {p->lstate = EXPR_FNAME;}
 7413|      0|#line 7414 "mrbgems/mruby-compiler/core/y.tab.c"
 7414|      0|    break;
 7415|       |
 7416|      0|  case 127: /* undef_list: undef_list ',' $@6 fsym  */
  ------------------
  |  Branch (7416:3): [True: 0, False: 12.5M]
  ------------------
 7417|      0|#line 2211 "mrbgems/mruby-compiler/core/parse.y"
 7418|      0|                    {
 7419|      0|                      (yyval.nd) = push((yyvsp[-3].nd), nsym((yyvsp[0].id)));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 7420|      0|                    }
 7421|      0|#line 7422 "mrbgems/mruby-compiler/core/y.tab.c"
 7422|      0|    break;
 7423|       |
 7424|      0|  case 128: /* op: '|'  */
  ------------------
  |  Branch (7424:3): [True: 0, False: 12.5M]
  ------------------
 7425|      0|#line 2216 "mrbgems/mruby-compiler/core/parse.y"
 7426|      0|                                { (yyval.id) = intern_op(or);     }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7427|      0|#line 7428 "mrbgems/mruby-compiler/core/y.tab.c"
 7428|      0|    break;
 7429|       |
 7430|      0|  case 129: /* op: '^'  */
  ------------------
  |  Branch (7430:3): [True: 0, False: 12.5M]
  ------------------
 7431|      0|#line 2217 "mrbgems/mruby-compiler/core/parse.y"
 7432|      0|                                { (yyval.id) = intern_op(xor);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7433|      0|#line 7434 "mrbgems/mruby-compiler/core/y.tab.c"
 7434|      0|    break;
 7435|       |
 7436|      0|  case 130: /* op: '&'  */
  ------------------
  |  Branch (7436:3): [True: 0, False: 12.5M]
  ------------------
 7437|      0|#line 2218 "mrbgems/mruby-compiler/core/parse.y"
 7438|      0|                                { (yyval.id) = intern_op(and);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7439|      0|#line 7440 "mrbgems/mruby-compiler/core/y.tab.c"
 7440|      0|    break;
 7441|       |
 7442|      0|  case 131: /* op: "<=>"  */
  ------------------
  |  Branch (7442:3): [True: 0, False: 12.5M]
  ------------------
 7443|      0|#line 2219 "mrbgems/mruby-compiler/core/parse.y"
 7444|      0|                                { (yyval.id) = intern_op(cmp);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7445|      0|#line 7446 "mrbgems/mruby-compiler/core/y.tab.c"
 7446|      0|    break;
 7447|       |
 7448|      0|  case 132: /* op: "=="  */
  ------------------
  |  Branch (7448:3): [True: 0, False: 12.5M]
  ------------------
 7449|      0|#line 2220 "mrbgems/mruby-compiler/core/parse.y"
 7450|      0|                                { (yyval.id) = intern_op(eq);     }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7451|      0|#line 7452 "mrbgems/mruby-compiler/core/y.tab.c"
 7452|      0|    break;
 7453|       |
 7454|      0|  case 133: /* op: "==="  */
  ------------------
  |  Branch (7454:3): [True: 0, False: 12.5M]
  ------------------
 7455|      0|#line 2221 "mrbgems/mruby-compiler/core/parse.y"
 7456|      0|                                { (yyval.id) = intern_op(eqq);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7457|      0|#line 7458 "mrbgems/mruby-compiler/core/y.tab.c"
 7458|      0|    break;
 7459|       |
 7460|      0|  case 134: /* op: "=~"  */
  ------------------
  |  Branch (7460:3): [True: 0, False: 12.5M]
  ------------------
 7461|      0|#line 2222 "mrbgems/mruby-compiler/core/parse.y"
 7462|      0|                                { (yyval.id) = intern_op(match);  }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7463|      0|#line 7464 "mrbgems/mruby-compiler/core/y.tab.c"
 7464|      0|    break;
 7465|       |
 7466|      0|  case 135: /* op: "!~"  */
  ------------------
  |  Branch (7466:3): [True: 0, False: 12.5M]
  ------------------
 7467|      0|#line 2223 "mrbgems/mruby-compiler/core/parse.y"
 7468|      0|                                { (yyval.id) = intern_op(nmatch); }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7469|      0|#line 7470 "mrbgems/mruby-compiler/core/y.tab.c"
 7470|      0|    break;
 7471|       |
 7472|      0|  case 136: /* op: '>'  */
  ------------------
  |  Branch (7472:3): [True: 0, False: 12.5M]
  ------------------
 7473|      0|#line 2224 "mrbgems/mruby-compiler/core/parse.y"
 7474|      0|                                { (yyval.id) = intern_op(gt);     }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7475|      0|#line 7476 "mrbgems/mruby-compiler/core/y.tab.c"
 7476|      0|    break;
 7477|       |
 7478|      0|  case 137: /* op: ">="  */
  ------------------
  |  Branch (7478:3): [True: 0, False: 12.5M]
  ------------------
 7479|      0|#line 2225 "mrbgems/mruby-compiler/core/parse.y"
 7480|      0|                                { (yyval.id) = intern_op(ge);     }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7481|      0|#line 7482 "mrbgems/mruby-compiler/core/y.tab.c"
 7482|      0|    break;
 7483|       |
 7484|      0|  case 138: /* op: '<'  */
  ------------------
  |  Branch (7484:3): [True: 0, False: 12.5M]
  ------------------
 7485|      0|#line 2226 "mrbgems/mruby-compiler/core/parse.y"
 7486|      0|                                { (yyval.id) = intern_op(lt);     }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7487|      0|#line 7488 "mrbgems/mruby-compiler/core/y.tab.c"
 7488|      0|    break;
 7489|       |
 7490|      0|  case 139: /* op: "<="  */
  ------------------
  |  Branch (7490:3): [True: 0, False: 12.5M]
  ------------------
 7491|      0|#line 2227 "mrbgems/mruby-compiler/core/parse.y"
 7492|      0|                                { (yyval.id) = intern_op(le);     }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7493|      0|#line 7494 "mrbgems/mruby-compiler/core/y.tab.c"
 7494|      0|    break;
 7495|       |
 7496|      0|  case 140: /* op: "!="  */
  ------------------
  |  Branch (7496:3): [True: 0, False: 12.5M]
  ------------------
 7497|      0|#line 2228 "mrbgems/mruby-compiler/core/parse.y"
 7498|      0|                                { (yyval.id) = intern_op(neq);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7499|      0|#line 7500 "mrbgems/mruby-compiler/core/y.tab.c"
 7500|      0|    break;
 7501|       |
 7502|      0|  case 141: /* op: "<<"  */
  ------------------
  |  Branch (7502:3): [True: 0, False: 12.5M]
  ------------------
 7503|      0|#line 2229 "mrbgems/mruby-compiler/core/parse.y"
 7504|      0|                                { (yyval.id) = intern_op(lshift); }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7505|      0|#line 7506 "mrbgems/mruby-compiler/core/y.tab.c"
 7506|      0|    break;
 7507|       |
 7508|      0|  case 142: /* op: ">>"  */
  ------------------
  |  Branch (7508:3): [True: 0, False: 12.5M]
  ------------------
 7509|      0|#line 2230 "mrbgems/mruby-compiler/core/parse.y"
 7510|      0|                                { (yyval.id) = intern_op(rshift); }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7511|      0|#line 7512 "mrbgems/mruby-compiler/core/y.tab.c"
 7512|      0|    break;
 7513|       |
 7514|      0|  case 143: /* op: '+'  */
  ------------------
  |  Branch (7514:3): [True: 0, False: 12.5M]
  ------------------
 7515|      0|#line 2231 "mrbgems/mruby-compiler/core/parse.y"
 7516|      0|                                { (yyval.id) = intern_op(add);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7517|      0|#line 7518 "mrbgems/mruby-compiler/core/y.tab.c"
 7518|      0|    break;
 7519|       |
 7520|      0|  case 144: /* op: '-'  */
  ------------------
  |  Branch (7520:3): [True: 0, False: 12.5M]
  ------------------
 7521|      0|#line 2232 "mrbgems/mruby-compiler/core/parse.y"
 7522|      0|                                { (yyval.id) = intern_op(sub);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7523|      0|#line 7524 "mrbgems/mruby-compiler/core/y.tab.c"
 7524|      0|    break;
 7525|       |
 7526|      0|  case 145: /* op: '*'  */
  ------------------
  |  Branch (7526:3): [True: 0, False: 12.5M]
  ------------------
 7527|      0|#line 2233 "mrbgems/mruby-compiler/core/parse.y"
 7528|      0|                                { (yyval.id) = intern_op(mul);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7529|      0|#line 7530 "mrbgems/mruby-compiler/core/y.tab.c"
 7530|      0|    break;
 7531|       |
 7532|      0|  case 146: /* op: "*"  */
  ------------------
  |  Branch (7532:3): [True: 0, False: 12.5M]
  ------------------
 7533|      0|#line 2234 "mrbgems/mruby-compiler/core/parse.y"
 7534|      0|                                { (yyval.id) = intern_op(mul);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7535|      0|#line 7536 "mrbgems/mruby-compiler/core/y.tab.c"
 7536|      0|    break;
 7537|       |
 7538|      0|  case 147: /* op: '/'  */
  ------------------
  |  Branch (7538:3): [True: 0, False: 12.5M]
  ------------------
 7539|      0|#line 2235 "mrbgems/mruby-compiler/core/parse.y"
 7540|      0|                                { (yyval.id) = intern_op(div);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7541|      0|#line 7542 "mrbgems/mruby-compiler/core/y.tab.c"
 7542|      0|    break;
 7543|       |
 7544|      0|  case 148: /* op: '%'  */
  ------------------
  |  Branch (7544:3): [True: 0, False: 12.5M]
  ------------------
 7545|      0|#line 2236 "mrbgems/mruby-compiler/core/parse.y"
 7546|      0|                                { (yyval.id) = intern_op(mod);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7547|      0|#line 7548 "mrbgems/mruby-compiler/core/y.tab.c"
 7548|      0|    break;
 7549|       |
 7550|      0|  case 149: /* op: tPOW  */
  ------------------
  |  Branch (7550:3): [True: 0, False: 12.5M]
  ------------------
 7551|      0|#line 2237 "mrbgems/mruby-compiler/core/parse.y"
 7552|      0|                                { (yyval.id) = intern_op(pow);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7553|      0|#line 7554 "mrbgems/mruby-compiler/core/y.tab.c"
 7554|      0|    break;
 7555|       |
 7556|      0|  case 150: /* op: "**"  */
  ------------------
  |  Branch (7556:3): [True: 0, False: 12.5M]
  ------------------
 7557|      0|#line 2238 "mrbgems/mruby-compiler/core/parse.y"
 7558|      0|                                { (yyval.id) = intern_op(pow);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7559|      0|#line 7560 "mrbgems/mruby-compiler/core/y.tab.c"
 7560|      0|    break;
 7561|       |
 7562|      0|  case 151: /* op: '!'  */
  ------------------
  |  Branch (7562:3): [True: 0, False: 12.5M]
  ------------------
 7563|      0|#line 2239 "mrbgems/mruby-compiler/core/parse.y"
 7564|      0|                                { (yyval.id) = intern_op(not);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7565|      0|#line 7566 "mrbgems/mruby-compiler/core/y.tab.c"
 7566|      0|    break;
 7567|       |
 7568|      0|  case 152: /* op: '~'  */
  ------------------
  |  Branch (7568:3): [True: 0, False: 12.5M]
  ------------------
 7569|      0|#line 2240 "mrbgems/mruby-compiler/core/parse.y"
 7570|      0|                                { (yyval.id) = intern_op(neg);    }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7571|      0|#line 7572 "mrbgems/mruby-compiler/core/y.tab.c"
 7572|      0|    break;
 7573|       |
 7574|      0|  case 153: /* op: "unary plus"  */
  ------------------
  |  Branch (7574:3): [True: 0, False: 12.5M]
  ------------------
 7575|      0|#line 2241 "mrbgems/mruby-compiler/core/parse.y"
 7576|      0|                                { (yyval.id) = intern_op(plus);   }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7577|      0|#line 7578 "mrbgems/mruby-compiler/core/y.tab.c"
 7578|      0|    break;
 7579|       |
 7580|      0|  case 154: /* op: "unary minus"  */
  ------------------
  |  Branch (7580:3): [True: 0, False: 12.5M]
  ------------------
 7581|      0|#line 2242 "mrbgems/mruby-compiler/core/parse.y"
 7582|      0|                                { (yyval.id) = intern_op(minus);  }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7583|      0|#line 7584 "mrbgems/mruby-compiler/core/y.tab.c"
 7584|      0|    break;
 7585|       |
 7586|      0|  case 155: /* op: tAREF  */
  ------------------
  |  Branch (7586:3): [True: 0, False: 12.5M]
  ------------------
 7587|      0|#line 2243 "mrbgems/mruby-compiler/core/parse.y"
 7588|      0|                                { (yyval.id) = intern_op(aref);   }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7589|      0|#line 7590 "mrbgems/mruby-compiler/core/y.tab.c"
 7590|      0|    break;
 7591|       |
 7592|      0|  case 156: /* op: tASET  */
  ------------------
  |  Branch (7592:3): [True: 0, False: 12.5M]
  ------------------
 7593|      0|#line 2244 "mrbgems/mruby-compiler/core/parse.y"
 7594|      0|                                { (yyval.id) = intern_op(aset);   }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7595|      0|#line 7596 "mrbgems/mruby-compiler/core/y.tab.c"
 7596|      0|    break;
 7597|       |
 7598|      0|  case 157: /* op: '`'  */
  ------------------
  |  Branch (7598:3): [True: 0, False: 12.5M]
  ------------------
 7599|      0|#line 2245 "mrbgems/mruby-compiler/core/parse.y"
 7600|      0|                                { (yyval.id) = intern_op(tick);   }
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7601|      0|#line 7602 "mrbgems/mruby-compiler/core/y.tab.c"
 7602|      0|    break;
 7603|       |
 7604|   214k|  case 198: /* arg: lhs '=' arg_rhs  */
  ------------------
  |  Branch (7604:3): [True: 214k, False: 12.3M]
  ------------------
 7605|   214k|#line 2263 "mrbgems/mruby-compiler/core/parse.y"
 7606|   214k|                    {
 7607|   214k|                      (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 7608|   214k|                    }
 7609|   214k|#line 7610 "mrbgems/mruby-compiler/core/y.tab.c"
 7610|   214k|    break;
 7611|       |
 7612|  31.8k|  case 199: /* arg: var_lhs tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7612:3): [True: 31.8k, False: 12.5M]
  ------------------
 7613|  31.8k|#line 2267 "mrbgems/mruby-compiler/core/parse.y"
 7614|  31.8k|                    {
 7615|  31.8k|                      (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
 7616|  31.8k|                    }
 7617|  31.8k|#line 7618 "mrbgems/mruby-compiler/core/y.tab.c"
 7618|  31.8k|    break;
 7619|       |
 7620|      0|  case 200: /* arg: primary_value '[' opt_call_args ']' tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7620:3): [True: 0, False: 12.5M]
  ------------------
 7621|      0|#line 2271 "mrbgems/mruby-compiler/core/parse.y"
 7622|      0|                    {
 7623|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 7624|      0|                    }
 7625|      0|#line 7626 "mrbgems/mruby-compiler/core/y.tab.c"
 7626|      0|    break;
 7627|       |
 7628|      0|  case 201: /* arg: primary_value call_op "local variable or method" tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7628:3): [True: 0, False: 12.5M]
  ------------------
 7629|      0|#line 2275 "mrbgems/mruby-compiler/core/parse.y"
 7630|      0|                    {
 7631|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
 7632|      0|                    }
 7633|      0|#line 7634 "mrbgems/mruby-compiler/core/y.tab.c"
 7634|      0|    break;
 7635|       |
 7636|      0|  case 202: /* arg: primary_value call_op "constant" tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7636:3): [True: 0, False: 12.5M]
  ------------------
 7637|      0|#line 2279 "mrbgems/mruby-compiler/core/parse.y"
 7638|      0|                    {
 7639|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
 7640|      0|                    }
 7641|      0|#line 7642 "mrbgems/mruby-compiler/core/y.tab.c"
 7642|      0|    break;
 7643|       |
 7644|      0|  case 203: /* arg: primary_value "::" "local variable or method" tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7644:3): [True: 0, False: 12.5M]
  ------------------
 7645|      0|#line 2283 "mrbgems/mruby-compiler/core/parse.y"
 7646|      0|                    {
 7647|      0|                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
 7648|      0|                    }
 7649|      0|#line 7650 "mrbgems/mruby-compiler/core/y.tab.c"
 7650|      0|    break;
 7651|       |
 7652|      0|  case 204: /* arg: primary_value "::" "constant" tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7652:3): [True: 0, False: 12.5M]
  ------------------
 7653|      0|#line 2287 "mrbgems/mruby-compiler/core/parse.y"
 7654|      0|                    {
 7655|      0|                      yyerror(p, "constant re-assignment");
 7656|      0|                      (yyval.nd) = new_begin(p, 0);
 7657|      0|                    }
 7658|      0|#line 7659 "mrbgems/mruby-compiler/core/y.tab.c"
 7659|      0|    break;
 7660|       |
 7661|      0|  case 205: /* arg: tCOLON3 "constant" tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7661:3): [True: 0, False: 12.5M]
  ------------------
 7662|      0|#line 2292 "mrbgems/mruby-compiler/core/parse.y"
 7663|      0|                    {
 7664|      0|                      yyerror(p, "constant re-assignment");
 7665|      0|                      (yyval.nd) = new_begin(p, 0);
 7666|      0|                    }
 7667|      0|#line 7668 "mrbgems/mruby-compiler/core/y.tab.c"
 7668|      0|    break;
 7669|       |
 7670|      0|  case 206: /* arg: backref tOP_ASGN arg_rhs  */
  ------------------
  |  Branch (7670:3): [True: 0, False: 12.5M]
  ------------------
 7671|      0|#line 2297 "mrbgems/mruby-compiler/core/parse.y"
 7672|      0|                    {
 7673|      0|                      backref_error(p, (yyvsp[-2].nd));
 7674|      0|                      (yyval.nd) = new_begin(p, 0);
 7675|      0|                    }
 7676|      0|#line 7677 "mrbgems/mruby-compiler/core/y.tab.c"
 7677|      0|    break;
 7678|       |
 7679|      0|  case 207: /* arg: arg ".." arg  */
  ------------------
  |  Branch (7679:3): [True: 0, False: 12.5M]
  ------------------
 7680|      0|#line 2302 "mrbgems/mruby-compiler/core/parse.y"
 7681|      0|                    {
 7682|      0|                      (yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 7683|      0|                    }
 7684|      0|#line 7685 "mrbgems/mruby-compiler/core/y.tab.c"
 7685|      0|    break;
 7686|       |
 7687|      0|  case 208: /* arg: arg ".."  */
  ------------------
  |  Branch (7687:3): [True: 0, False: 12.5M]
  ------------------
 7688|      0|#line 2306 "mrbgems/mruby-compiler/core/parse.y"
 7689|      0|                    {
 7690|      0|                      (yyval.nd) = new_dot2(p, (yyvsp[-1].nd), new_nil(p));
 7691|      0|                    }
 7692|      0|#line 7693 "mrbgems/mruby-compiler/core/y.tab.c"
 7693|      0|    break;
 7694|       |
 7695|      0|  case 209: /* arg: tBDOT2 arg  */
  ------------------
  |  Branch (7695:3): [True: 0, False: 12.5M]
  ------------------
 7696|      0|#line 2310 "mrbgems/mruby-compiler/core/parse.y"
 7697|      0|                    {
 7698|      0|                      (yyval.nd) = new_dot2(p, new_nil(p), (yyvsp[0].nd));
 7699|      0|                    }
 7700|      0|#line 7701 "mrbgems/mruby-compiler/core/y.tab.c"
 7701|      0|    break;
 7702|       |
 7703|      0|  case 210: /* arg: arg "..." arg  */
  ------------------
  |  Branch (7703:3): [True: 0, False: 12.5M]
  ------------------
 7704|      0|#line 2314 "mrbgems/mruby-compiler/core/parse.y"
 7705|      0|                    {
 7706|      0|                      (yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 7707|      0|                    }
 7708|      0|#line 7709 "mrbgems/mruby-compiler/core/y.tab.c"
 7709|      0|    break;
 7710|       |
 7711|      0|  case 211: /* arg: arg "..."  */
  ------------------
  |  Branch (7711:3): [True: 0, False: 12.5M]
  ------------------
 7712|      0|#line 2318 "mrbgems/mruby-compiler/core/parse.y"
 7713|      0|                    {
 7714|      0|                      (yyval.nd) = new_dot3(p, (yyvsp[-1].nd), new_nil(p));
 7715|      0|                    }
 7716|      0|#line 7717 "mrbgems/mruby-compiler/core/y.tab.c"
 7717|      0|    break;
 7718|       |
 7719|      0|  case 212: /* arg: tBDOT3 arg  */
  ------------------
  |  Branch (7719:3): [True: 0, False: 12.5M]
  ------------------
 7720|      0|#line 2322 "mrbgems/mruby-compiler/core/parse.y"
 7721|      0|                    {
 7722|      0|                      (yyval.nd) = new_dot3(p, new_nil(p), (yyvsp[0].nd));
 7723|      0|                    }
 7724|      0|#line 7725 "mrbgems/mruby-compiler/core/y.tab.c"
 7725|      0|    break;
 7726|       |
 7727|  19.7k|  case 213: /* arg: arg '+' arg  */
  ------------------
  |  Branch (7727:3): [True: 19.7k, False: 12.5M]
  ------------------
 7728|  19.7k|#line 2326 "mrbgems/mruby-compiler/core/parse.y"
 7729|  19.7k|                    {
 7730|  19.7k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd));
 7731|  19.7k|                    }
 7732|  19.7k|#line 7733 "mrbgems/mruby-compiler/core/y.tab.c"
 7733|  19.7k|    break;
 7734|       |
 7735|  21.9k|  case 214: /* arg: arg '-' arg  */
  ------------------
  |  Branch (7735:3): [True: 21.9k, False: 12.5M]
  ------------------
 7736|  21.9k|#line 2330 "mrbgems/mruby-compiler/core/parse.y"
 7737|  21.9k|                    {
 7738|  21.9k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd));
 7739|  21.9k|                    }
 7740|  21.9k|#line 7741 "mrbgems/mruby-compiler/core/y.tab.c"
 7741|  21.9k|    break;
 7742|       |
 7743|  18.2k|  case 215: /* arg: arg '*' arg  */
  ------------------
  |  Branch (7743:3): [True: 18.2k, False: 12.5M]
  ------------------
 7744|  18.2k|#line 2334 "mrbgems/mruby-compiler/core/parse.y"
 7745|  18.2k|                    {
 7746|  18.2k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd));
 7747|  18.2k|                    }
 7748|  18.2k|#line 7749 "mrbgems/mruby-compiler/core/y.tab.c"
 7749|  18.2k|    break;
 7750|       |
 7751|  12.8k|  case 216: /* arg: arg '/' arg  */
  ------------------
  |  Branch (7751:3): [True: 12.8k, False: 12.5M]
  ------------------
 7752|  12.8k|#line 2338 "mrbgems/mruby-compiler/core/parse.y"
 7753|  12.8k|                    {
 7754|  12.8k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd));
 7755|  12.8k|                    }
 7756|  12.8k|#line 7757 "mrbgems/mruby-compiler/core/y.tab.c"
 7757|  12.8k|    break;
 7758|       |
 7759|  9.50k|  case 217: /* arg: arg '%' arg  */
  ------------------
  |  Branch (7759:3): [True: 9.50k, False: 12.5M]
  ------------------
 7760|  9.50k|#line 2342 "mrbgems/mruby-compiler/core/parse.y"
 7761|  9.50k|                    {
 7762|  9.50k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd));
 7763|  9.50k|                    }
 7764|  9.50k|#line 7765 "mrbgems/mruby-compiler/core/y.tab.c"
 7765|  9.50k|    break;
 7766|       |
 7767|      0|  case 218: /* arg: arg tPOW arg  */
  ------------------
  |  Branch (7767:3): [True: 0, False: 12.5M]
  ------------------
 7768|      0|#line 2346 "mrbgems/mruby-compiler/core/parse.y"
 7769|      0|                    {
 7770|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd));
 7771|      0|                    }
 7772|      0|#line 7773 "mrbgems/mruby-compiler/core/y.tab.c"
 7773|      0|    break;
 7774|       |
 7775|      0|  case 219: /* arg: tUMINUS_NUM "integer literal" tPOW arg  */
  ------------------
  |  Branch (7775:3): [True: 0, False: 12.5M]
  ------------------
 7776|      0|#line 2350 "mrbgems/mruby-compiler/core/parse.y"
 7777|      0|                    {
 7778|      0|                      (yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)));
 7779|      0|                    }
 7780|      0|#line 7781 "mrbgems/mruby-compiler/core/y.tab.c"
 7781|      0|    break;
 7782|       |
 7783|      0|  case 220: /* arg: tUMINUS_NUM "float literal" tPOW arg  */
  ------------------
  |  Branch (7783:3): [True: 0, False: 12.5M]
  ------------------
 7784|      0|#line 2354 "mrbgems/mruby-compiler/core/parse.y"
 7785|      0|                    {
 7786|      0|                      (yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)));
 7787|      0|                    }
 7788|      0|#line 7789 "mrbgems/mruby-compiler/core/y.tab.c"
 7789|      0|    break;
 7790|       |
 7791|      0|  case 221: /* arg: "unary plus" arg  */
  ------------------
  |  Branch (7791:3): [True: 0, False: 12.5M]
  ------------------
 7792|      0|#line 2358 "mrbgems/mruby-compiler/core/parse.y"
 7793|      0|                    {
 7794|      0|                      (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@");
 7795|      0|                    }
 7796|      0|#line 7797 "mrbgems/mruby-compiler/core/y.tab.c"
 7797|      0|    break;
 7798|       |
 7799|      0|  case 222: /* arg: "unary minus" arg  */
  ------------------
  |  Branch (7799:3): [True: 0, False: 12.5M]
  ------------------
 7800|      0|#line 2362 "mrbgems/mruby-compiler/core/parse.y"
 7801|      0|                    {
 7802|      0|                      (yyval.nd) = new_negate(p, (yyvsp[0].nd));
 7803|      0|                    }
 7804|      0|#line 7805 "mrbgems/mruby-compiler/core/y.tab.c"
 7805|      0|    break;
 7806|       |
 7807|      0|  case 223: /* arg: arg '|' arg  */
  ------------------
  |  Branch (7807:3): [True: 0, False: 12.5M]
  ------------------
 7808|      0|#line 2366 "mrbgems/mruby-compiler/core/parse.y"
 7809|      0|                    {
 7810|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd));
 7811|      0|                    }
 7812|      0|#line 7813 "mrbgems/mruby-compiler/core/y.tab.c"
 7813|      0|    break;
 7814|       |
 7815|  9.95k|  case 224: /* arg: arg '^' arg  */
  ------------------
  |  Branch (7815:3): [True: 9.95k, False: 12.5M]
  ------------------
 7816|  9.95k|#line 2370 "mrbgems/mruby-compiler/core/parse.y"
 7817|  9.95k|                    {
 7818|  9.95k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd));
 7819|  9.95k|                    }
 7820|  9.95k|#line 7821 "mrbgems/mruby-compiler/core/y.tab.c"
 7821|  9.95k|    break;
 7822|       |
 7823|      0|  case 225: /* arg: arg '&' arg  */
  ------------------
  |  Branch (7823:3): [True: 0, False: 12.5M]
  ------------------
 7824|      0|#line 2374 "mrbgems/mruby-compiler/core/parse.y"
 7825|      0|                    {
 7826|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd));
 7827|      0|                    }
 7828|      0|#line 7829 "mrbgems/mruby-compiler/core/y.tab.c"
 7829|      0|    break;
 7830|       |
 7831|      0|  case 226: /* arg: arg "<=>" arg  */
  ------------------
  |  Branch (7831:3): [True: 0, False: 12.5M]
  ------------------
 7832|      0|#line 2378 "mrbgems/mruby-compiler/core/parse.y"
 7833|      0|                    {
 7834|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd));
 7835|      0|                    }
 7836|      0|#line 7837 "mrbgems/mruby-compiler/core/y.tab.c"
 7837|      0|    break;
 7838|       |
 7839|  1.51k|  case 227: /* arg: arg '>' arg  */
  ------------------
  |  Branch (7839:3): [True: 1.51k, False: 12.5M]
  ------------------
 7840|  1.51k|#line 2382 "mrbgems/mruby-compiler/core/parse.y"
 7841|  1.51k|                    {
 7842|  1.51k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd));
 7843|  1.51k|                    }
 7844|  1.51k|#line 7845 "mrbgems/mruby-compiler/core/y.tab.c"
 7845|  1.51k|    break;
 7846|       |
 7847|  1.92k|  case 228: /* arg: arg ">=" arg  */
  ------------------
  |  Branch (7847:3): [True: 1.92k, False: 12.5M]
  ------------------
 7848|  1.92k|#line 2386 "mrbgems/mruby-compiler/core/parse.y"
 7849|  1.92k|                    {
 7850|  1.92k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd));
 7851|  1.92k|                    }
 7852|  1.92k|#line 7853 "mrbgems/mruby-compiler/core/y.tab.c"
 7853|  1.92k|    break;
 7854|       |
 7855|  1.41k|  case 229: /* arg: arg '<' arg  */
  ------------------
  |  Branch (7855:3): [True: 1.41k, False: 12.5M]
  ------------------
 7856|  1.41k|#line 2390 "mrbgems/mruby-compiler/core/parse.y"
 7857|  1.41k|                    {
 7858|  1.41k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd));
 7859|  1.41k|                    }
 7860|  1.41k|#line 7861 "mrbgems/mruby-compiler/core/y.tab.c"
 7861|  1.41k|    break;
 7862|       |
 7863|  4.13k|  case 230: /* arg: arg "<=" arg  */
  ------------------
  |  Branch (7863:3): [True: 4.13k, False: 12.5M]
  ------------------
 7864|  4.13k|#line 2394 "mrbgems/mruby-compiler/core/parse.y"
 7865|  4.13k|                    {
 7866|  4.13k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd));
 7867|  4.13k|                    }
 7868|  4.13k|#line 7869 "mrbgems/mruby-compiler/core/y.tab.c"
 7869|  4.13k|    break;
 7870|       |
 7871|  2.45k|  case 231: /* arg: arg "==" arg  */
  ------------------
  |  Branch (7871:3): [True: 2.45k, False: 12.5M]
  ------------------
 7872|  2.45k|#line 2398 "mrbgems/mruby-compiler/core/parse.y"
 7873|  2.45k|                    {
 7874|  2.45k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd));
 7875|  2.45k|                    }
 7876|  2.45k|#line 7877 "mrbgems/mruby-compiler/core/y.tab.c"
 7877|  2.45k|    break;
 7878|       |
 7879|      0|  case 232: /* arg: arg "===" arg  */
  ------------------
  |  Branch (7879:3): [True: 0, False: 12.5M]
  ------------------
 7880|      0|#line 2402 "mrbgems/mruby-compiler/core/parse.y"
 7881|      0|                    {
 7882|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd));
 7883|      0|                    }
 7884|      0|#line 7885 "mrbgems/mruby-compiler/core/y.tab.c"
 7885|      0|    break;
 7886|       |
 7887|  6.40k|  case 233: /* arg: arg "!=" arg  */
  ------------------
  |  Branch (7887:3): [True: 6.40k, False: 12.5M]
  ------------------
 7888|  6.40k|#line 2406 "mrbgems/mruby-compiler/core/parse.y"
 7889|  6.40k|                    {
 7890|  6.40k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd));
 7891|  6.40k|                    }
 7892|  6.40k|#line 7893 "mrbgems/mruby-compiler/core/y.tab.c"
 7893|  6.40k|    break;
 7894|       |
 7895|      0|  case 234: /* arg: arg "=~" arg  */
  ------------------
  |  Branch (7895:3): [True: 0, False: 12.5M]
  ------------------
 7896|      0|#line 2410 "mrbgems/mruby-compiler/core/parse.y"
 7897|      0|                    {
 7898|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd));
 7899|      0|                    }
 7900|      0|#line 7901 "mrbgems/mruby-compiler/core/y.tab.c"
 7901|      0|    break;
 7902|       |
 7903|      0|  case 235: /* arg: arg "!~" arg  */
  ------------------
  |  Branch (7903:3): [True: 0, False: 12.5M]
  ------------------
 7904|      0|#line 2414 "mrbgems/mruby-compiler/core/parse.y"
 7905|      0|                    {
 7906|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd));
 7907|      0|                    }
 7908|      0|#line 7909 "mrbgems/mruby-compiler/core/y.tab.c"
 7909|      0|    break;
 7910|       |
 7911|      0|  case 236: /* arg: '!' arg  */
  ------------------
  |  Branch (7911:3): [True: 0, False: 12.5M]
  ------------------
 7912|      0|#line 2418 "mrbgems/mruby-compiler/core/parse.y"
 7913|      0|                    {
 7914|      0|                      (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
 7915|      0|                    }
 7916|      0|#line 7917 "mrbgems/mruby-compiler/core/y.tab.c"
 7917|      0|    break;
 7918|       |
 7919|      0|  case 237: /* arg: '~' arg  */
  ------------------
  |  Branch (7919:3): [True: 0, False: 12.5M]
  ------------------
 7920|      0|#line 2422 "mrbgems/mruby-compiler/core/parse.y"
 7921|      0|                    {
 7922|      0|                      (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~");
 7923|      0|                    }
 7924|      0|#line 7925 "mrbgems/mruby-compiler/core/y.tab.c"
 7925|      0|    break;
 7926|       |
 7927|      0|  case 238: /* arg: arg "<<" arg  */
  ------------------
  |  Branch (7927:3): [True: 0, False: 12.5M]
  ------------------
 7928|      0|#line 2426 "mrbgems/mruby-compiler/core/parse.y"
 7929|      0|                    {
 7930|      0|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd));
 7931|      0|                    }
 7932|      0|#line 7933 "mrbgems/mruby-compiler/core/y.tab.c"
 7933|      0|    break;
 7934|       |
 7935|  14.0k|  case 239: /* arg: arg ">>" arg  */
  ------------------
  |  Branch (7935:3): [True: 14.0k, False: 12.5M]
  ------------------
 7936|  14.0k|#line 2430 "mrbgems/mruby-compiler/core/parse.y"
 7937|  14.0k|                    {
 7938|  14.0k|                      (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd));
 7939|  14.0k|                    }
 7940|  14.0k|#line 7941 "mrbgems/mruby-compiler/core/y.tab.c"
 7941|  14.0k|    break;
 7942|       |
 7943|      0|  case 240: /* arg: arg "&&" arg  */
  ------------------
  |  Branch (7943:3): [True: 0, False: 12.5M]
  ------------------
 7944|      0|#line 2434 "mrbgems/mruby-compiler/core/parse.y"
 7945|      0|                    {
 7946|      0|                      (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 7947|      0|                    }
 7948|      0|#line 7949 "mrbgems/mruby-compiler/core/y.tab.c"
 7949|      0|    break;
 7950|       |
 7951|      0|  case 241: /* arg: arg "||" arg  */
  ------------------
  |  Branch (7951:3): [True: 0, False: 12.5M]
  ------------------
 7952|      0|#line 2438 "mrbgems/mruby-compiler/core/parse.y"
 7953|      0|                    {
 7954|      0|                      (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 7955|      0|                    }
 7956|      0|#line 7957 "mrbgems/mruby-compiler/core/y.tab.c"
 7957|      0|    break;
 7958|       |
 7959|  8.56k|  case 242: /* arg: arg '?' arg opt_nl ':' arg  */
  ------------------
  |  Branch (7959:3): [True: 8.56k, False: 12.5M]
  ------------------
 7960|  8.56k|#line 2442 "mrbgems/mruby-compiler/core/parse.y"
 7961|  8.56k|                    {
 7962|  8.56k|                      (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
 7963|  8.56k|                    }
 7964|  8.56k|#line 7965 "mrbgems/mruby-compiler/core/y.tab.c"
 7965|  8.56k|    break;
 7966|       |
 7967|      0|  case 243: /* arg: arg '?' arg opt_nl "label" arg  */
  ------------------
  |  Branch (7967:3): [True: 0, False: 12.5M]
  ------------------
 7968|      0|#line 2446 "mrbgems/mruby-compiler/core/parse.y"
 7969|      0|                    {
 7970|      0|                      (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
 7971|      0|                    }
 7972|      0|#line 7973 "mrbgems/mruby-compiler/core/y.tab.c"
 7973|      0|    break;
 7974|       |
 7975|      0|  case 244: /* arg: defn_head f_opt_arglist_paren '=' arg  */
  ------------------
  |  Branch (7975:3): [True: 0, False: 12.5M]
  ------------------
 7976|      0|#line 2450 "mrbgems/mruby-compiler/core/parse.y"
 7977|      0|                    {
 7978|      0|                      (yyval.nd) = (yyvsp[-3].nd);
 7979|      0|                      endless_method_name(p, (yyvsp[-3].nd));
 7980|      0|                      void_expr_error(p, (yyvsp[0].nd));
 7981|      0|                      defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
 7982|      0|                      nvars_unnest(p);
 7983|      0|                      p->in_def--;
 7984|      0|                    }
 7985|      0|#line 7986 "mrbgems/mruby-compiler/core/y.tab.c"
 7986|      0|    break;
 7987|       |
 7988|      0|  case 245: /* arg: defn_head f_opt_arglist_paren '=' arg modifier_rescue arg  */
  ------------------
  |  Branch (7988:3): [True: 0, False: 12.5M]
  ------------------
 7989|      0|#line 2459 "mrbgems/mruby-compiler/core/parse.y"
 7990|      0|                    {
 7991|      0|                      (yyval.nd) = (yyvsp[-5].nd);
 7992|      0|                      endless_method_name(p, (yyvsp[-5].nd));
 7993|      0|                      void_expr_error(p, (yyvsp[-2].nd));
 7994|      0|                      defn_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
 7995|      0|                      nvars_unnest(p);
 7996|      0|                      p->in_def--;
 7997|      0|                    }
 7998|      0|#line 7999 "mrbgems/mruby-compiler/core/y.tab.c"
 7999|      0|    break;
 8000|       |
 8001|      0|  case 246: /* arg: defs_head f_opt_arglist_paren '=' arg  */
  ------------------
  |  Branch (8001:3): [True: 0, False: 12.5M]
  ------------------
 8002|      0|#line 2468 "mrbgems/mruby-compiler/core/parse.y"
 8003|      0|                    {
 8004|      0|                      (yyval.nd) = (yyvsp[-3].nd);
 8005|      0|                      void_expr_error(p, (yyvsp[0].nd));
 8006|      0|                      defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
 8007|      0|                      nvars_unnest(p);
 8008|      0|                      p->in_def--;
 8009|      0|                      p->in_single--;
 8010|      0|                    }
 8011|      0|#line 8012 "mrbgems/mruby-compiler/core/y.tab.c"
 8012|      0|    break;
 8013|       |
 8014|      0|  case 247: /* arg: defs_head f_opt_arglist_paren '=' arg modifier_rescue arg  */
  ------------------
  |  Branch (8014:3): [True: 0, False: 12.5M]
  ------------------
 8015|      0|#line 2477 "mrbgems/mruby-compiler/core/parse.y"
 8016|      0|                    {
 8017|      0|                      (yyval.nd) = (yyvsp[-5].nd);
 8018|      0|                      void_expr_error(p, (yyvsp[-2].nd));
 8019|      0|                      defs_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
 8020|      0|                      nvars_unnest(p);
 8021|      0|                      p->in_def--;
 8022|      0|                      p->in_single--;
 8023|      0|                    }
 8024|      0|#line 8025 "mrbgems/mruby-compiler/core/y.tab.c"
 8025|      0|    break;
 8026|       |
 8027|  1.37M|  case 248: /* arg: primary  */
  ------------------
  |  Branch (8027:3): [True: 1.37M, False: 11.1M]
  ------------------
 8028|  1.37M|#line 2486 "mrbgems/mruby-compiler/core/parse.y"
 8029|  1.37M|                    {
 8030|  1.37M|                      (yyval.nd) = (yyvsp[0].nd);
 8031|  1.37M|                    }
 8032|  1.37M|#line 8033 "mrbgems/mruby-compiler/core/y.tab.c"
 8033|  1.37M|    break;
 8034|       |
 8035|  55.7k|  case 250: /* aref_args: args trailer  */
  ------------------
  |  Branch (8035:3): [True: 55.7k, False: 12.4M]
  ------------------
 8036|  55.7k|#line 2493 "mrbgems/mruby-compiler/core/parse.y"
 8037|  55.7k|                    {
 8038|  55.7k|                      (yyval.nd) = (yyvsp[-1].nd);
 8039|  55.7k|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|  55.7k|#define NODE_LINENO(c,n) do {\
  |  |  126|  55.7k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 55.7k, False: 0]
  |  |  ------------------
  |  |  127|  55.7k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  55.7k|     (c)->lineno = (n)->lineno;\
  |  |  129|  55.7k|  }\
  |  |  130|  55.7k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8040|  55.7k|                    }
 8041|  55.7k|#line 8042 "mrbgems/mruby-compiler/core/y.tab.c"
 8042|  55.7k|    break;
 8043|       |
 8044|      0|  case 251: /* aref_args: args comma assocs trailer  */
  ------------------
  |  Branch (8044:3): [True: 0, False: 12.5M]
  ------------------
 8045|      0|#line 2498 "mrbgems/mruby-compiler/core/parse.y"
 8046|      0|                    {
 8047|      0|                      (yyval.nd) = push((yyvsp[-3].nd), new_hash(p, (yyvsp[-1].nd)));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8048|      0|                    }
 8049|      0|#line 8050 "mrbgems/mruby-compiler/core/y.tab.c"
 8050|      0|    break;
 8051|       |
 8052|      0|  case 252: /* aref_args: assocs trailer  */
  ------------------
  |  Branch (8052:3): [True: 0, False: 12.5M]
  ------------------
 8053|      0|#line 2502 "mrbgems/mruby-compiler/core/parse.y"
 8054|      0|                    {
 8055|      0|                      (yyval.nd) = cons(new_kw_hash(p, (yyvsp[-1].nd)), 0);
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 8056|      0|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8057|      0|                    }
 8058|      0|#line 8059 "mrbgems/mruby-compiler/core/y.tab.c"
 8059|      0|    break;
 8060|       |
 8061|   246k|  case 253: /* arg_rhs: arg  */
  ------------------
  |  Branch (8061:3): [True: 246k, False: 12.3M]
  ------------------
 8062|   246k|#line 2509 "mrbgems/mruby-compiler/core/parse.y"
 8063|   246k|                    {
 8064|   246k|                      (yyval.nd) = (yyvsp[0].nd);
 8065|   246k|                    }
 8066|   246k|#line 8067 "mrbgems/mruby-compiler/core/y.tab.c"
 8067|   246k|    break;
 8068|       |
 8069|      0|  case 254: /* arg_rhs: arg modifier_rescue arg  */
  ------------------
  |  Branch (8069:3): [True: 0, False: 12.5M]
  ------------------
 8070|      0|#line 2513 "mrbgems/mruby-compiler/core/parse.y"
 8071|      0|                    {
 8072|      0|                      void_expr_error(p, (yyvsp[-2].nd));
 8073|      0|                      (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 8074|      0|                    }
 8075|      0|#line 8076 "mrbgems/mruby-compiler/core/y.tab.c"
 8076|      0|    break;
 8077|       |
 8078|  95.8k|  case 255: /* paren_args: '(' opt_call_args ')'  */
  ------------------
  |  Branch (8078:3): [True: 95.8k, False: 12.4M]
  ------------------
 8079|  95.8k|#line 2520 "mrbgems/mruby-compiler/core/parse.y"
 8080|  95.8k|                    {
 8081|  95.8k|                      (yyval.nd) = (yyvsp[-1].nd);
 8082|  95.8k|                    }
 8083|  95.8k|#line 8084 "mrbgems/mruby-compiler/core/y.tab.c"
 8084|  95.8k|    break;
 8085|       |
 8086|      0|  case 256: /* paren_args: '(' args comma tBDOT3 rparen  */
  ------------------
  |  Branch (8086:3): [True: 0, False: 12.5M]
  ------------------
 8087|      0|#line 2524 "mrbgems/mruby-compiler/core/parse.y"
 8088|      0|                    {
 8089|      0|                      mrb_sym r = intern_op(mul);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8090|      0|                      mrb_sym k = intern_op(pow);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8091|      0|                      mrb_sym b = intern_op(and);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8092|      0|                      (yyval.nd) = new_callargs(p, push((yyvsp[-3].nd), new_splat(p, new_lvar(p, r))),
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8093|      0|                                        new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k)))),
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8094|      0|                                        new_block_arg(p, new_lvar(p, b)));
 8095|      0|                    }
 8096|      0|#line 8097 "mrbgems/mruby-compiler/core/y.tab.c"
 8097|      0|    break;
 8098|       |
 8099|      0|  case 257: /* paren_args: '(' tBDOT3 rparen  */
  ------------------
  |  Branch (8099:3): [True: 0, False: 12.5M]
  ------------------
 8100|      0|#line 2533 "mrbgems/mruby-compiler/core/parse.y"
 8101|      0|                    {
 8102|      0|                      mrb_sym r = intern_op(mul);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8103|      0|                      mrb_sym k = intern_op(pow);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8104|      0|                      mrb_sym b = intern_op(and);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8105|      0|                      if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
  ------------------
  |  Branch (8105:27): [True: 0, False: 0]
  |  Branch (8105:48): [True: 0, False: 0]
  |  Branch (8105:69): [True: 0, False: 0]
  ------------------
 8106|      0|                        (yyval.nd) = new_callargs(p, list1(new_splat(p, new_lvar(p, r))),
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8107|      0|                                          new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k)))),
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8108|      0|                                          new_block_arg(p, new_lvar(p, b)));
 8109|      0|                      }
 8110|      0|                      else {
 8111|      0|                        yyerror(p, "unexpected argument forwarding ...");
 8112|      0|                        (yyval.nd) = 0;
 8113|      0|                      }
 8114|      0|                    }
 8115|      0|#line 8116 "mrbgems/mruby-compiler/core/y.tab.c"
 8116|      0|    break;
 8117|       |
 8118|      0|  case 262: /* opt_call_args: args comma  */
  ------------------
  |  Branch (8118:3): [True: 0, False: 12.5M]
  ------------------
 8119|      0|#line 2556 "mrbgems/mruby-compiler/core/parse.y"
 8120|      0|                    {
 8121|      0|                      (yyval.nd) = new_callargs(p,(yyvsp[-1].nd),0,0);
 8122|      0|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8123|      0|                    }
 8124|      0|#line 8125 "mrbgems/mruby-compiler/core/y.tab.c"
 8125|      0|    break;
 8126|       |
 8127|      0|  case 263: /* opt_call_args: args comma assocs comma  */
  ------------------
  |  Branch (8127:3): [True: 0, False: 12.5M]
  ------------------
 8128|      0|#line 2561 "mrbgems/mruby-compiler/core/parse.y"
 8129|      0|                    {
 8130|      0|                      (yyval.nd) = new_callargs(p,(yyvsp[-3].nd),new_kw_hash(p,(yyvsp[-1].nd)),0);
 8131|      0|                      NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8132|      0|                    }
 8133|      0|#line 8134 "mrbgems/mruby-compiler/core/y.tab.c"
 8134|      0|    break;
 8135|       |
 8136|      0|  case 264: /* opt_call_args: assocs comma  */
  ------------------
  |  Branch (8136:3): [True: 0, False: 12.5M]
  ------------------
 8137|      0|#line 2566 "mrbgems/mruby-compiler/core/parse.y"
 8138|      0|                    {
 8139|      0|                      (yyval.nd) = new_callargs(p,0,new_kw_hash(p,(yyvsp[-1].nd)),0);
 8140|      0|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8141|      0|                    }
 8142|      0|#line 8143 "mrbgems/mruby-compiler/core/y.tab.c"
 8143|      0|    break;
 8144|       |
 8145|      0|  case 265: /* call_args: command  */
  ------------------
  |  Branch (8145:3): [True: 0, False: 12.5M]
  ------------------
 8146|      0|#line 2573 "mrbgems/mruby-compiler/core/parse.y"
 8147|      0|                    {
 8148|      0|                      void_expr_error(p, (yyvsp[0].nd));
 8149|      0|                      (yyval.nd) = new_callargs(p, list1((yyvsp[0].nd)), 0, 0);
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8150|      0|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8151|      0|                    }
 8152|      0|#line 8153 "mrbgems/mruby-compiler/core/y.tab.c"
 8153|      0|    break;
 8154|       |
 8155|  78.8k|  case 266: /* call_args: args opt_block_arg  */
  ------------------
  |  Branch (8155:3): [True: 78.8k, False: 12.4M]
  ------------------
 8156|  78.8k|#line 2579 "mrbgems/mruby-compiler/core/parse.y"
 8157|  78.8k|                    {
 8158|  78.8k|                      (yyval.nd) = new_callargs(p, (yyvsp[-1].nd), 0, (yyvsp[0].nd));
 8159|  78.8k|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|  78.8k|#define NODE_LINENO(c,n) do {\
  |  |  126|  78.8k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 78.8k, False: 0]
  |  |  ------------------
  |  |  127|  78.8k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  78.8k|     (c)->lineno = (n)->lineno;\
  |  |  129|  78.8k|  }\
  |  |  130|  78.8k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8160|  78.8k|                    }
 8161|  78.8k|#line 8162 "mrbgems/mruby-compiler/core/y.tab.c"
 8162|  78.8k|    break;
 8163|       |
 8164|      0|  case 267: /* call_args: assocs opt_block_arg  */
  ------------------
  |  Branch (8164:3): [True: 0, False: 12.5M]
  ------------------
 8165|      0|#line 2584 "mrbgems/mruby-compiler/core/parse.y"
 8166|      0|                    {
 8167|      0|                      (yyval.nd) = new_callargs(p, 0, new_kw_hash(p, (yyvsp[-1].nd)), (yyvsp[0].nd));
 8168|      0|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8169|      0|                    }
 8170|      0|#line 8171 "mrbgems/mruby-compiler/core/y.tab.c"
 8171|      0|    break;
 8172|       |
 8173|      0|  case 268: /* call_args: args comma assocs opt_block_arg  */
  ------------------
  |  Branch (8173:3): [True: 0, False: 12.5M]
  ------------------
 8174|      0|#line 2589 "mrbgems/mruby-compiler/core/parse.y"
 8175|      0|                    {
 8176|      0|                      (yyval.nd) = new_callargs(p, (yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd)), (yyvsp[0].nd));
 8177|      0|                      NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8178|      0|                    }
 8179|      0|#line 8180 "mrbgems/mruby-compiler/core/y.tab.c"
 8180|      0|    break;
 8181|       |
 8182|      0|  case 269: /* call_args: block_arg  */
  ------------------
  |  Branch (8182:3): [True: 0, False: 12.5M]
  ------------------
 8183|      0|#line 2594 "mrbgems/mruby-compiler/core/parse.y"
 8184|      0|                    {
 8185|      0|                      (yyval.nd) = new_callargs(p, 0, 0, (yyvsp[0].nd));
 8186|      0|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8187|      0|                    }
 8188|      0|#line 8189 "mrbgems/mruby-compiler/core/y.tab.c"
 8189|      0|    break;
 8190|       |
 8191|      0|  case 270: /* @7: %empty  */
  ------------------
  |  Branch (8191:3): [True: 0, False: 12.5M]
  ------------------
 8192|      0|#line 2600 "mrbgems/mruby-compiler/core/parse.y"
 8193|      0|                   {
 8194|      0|                      (yyval.stack) = p->cmdarg_stack;
 8195|      0|                      CMDARG_PUSH(1);
  ------------------
  |  |  119|      0|#define CMDARG_PUSH(n)  BITSTACK_PUSH(p->cmdarg_stack, (n))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
 8196|      0|                    }
 8197|      0|#line 8198 "mrbgems/mruby-compiler/core/y.tab.c"
 8198|      0|    break;
 8199|       |
 8200|      0|  case 271: /* command_args: @7 call_args  */
  ------------------
  |  Branch (8200:3): [True: 0, False: 12.5M]
  ------------------
 8201|      0|#line 2605 "mrbgems/mruby-compiler/core/parse.y"
 8202|      0|                    {
 8203|      0|                      p->cmdarg_stack = (yyvsp[-1].stack);
 8204|      0|                      (yyval.nd) = (yyvsp[0].nd);
 8205|      0|                    }
 8206|      0|#line 8207 "mrbgems/mruby-compiler/core/y.tab.c"
 8207|      0|    break;
 8208|       |
 8209|      0|  case 272: /* block_arg: "&" arg  */
  ------------------
  |  Branch (8209:3): [True: 0, False: 12.5M]
  ------------------
 8210|      0|#line 2612 "mrbgems/mruby-compiler/core/parse.y"
 8211|      0|                    {
 8212|      0|                      (yyval.nd) = new_block_arg(p, (yyvsp[0].nd));
 8213|      0|                    }
 8214|      0|#line 8215 "mrbgems/mruby-compiler/core/y.tab.c"
 8215|      0|    break;
 8216|       |
 8217|      0|  case 273: /* block_arg: "&"  */
  ------------------
  |  Branch (8217:3): [True: 0, False: 12.5M]
  ------------------
 8218|      0|#line 2616 "mrbgems/mruby-compiler/core/parse.y"
 8219|      0|                    {
 8220|      0|                      (yyval.nd) = new_block_arg(p, 0);
 8221|      0|                    }
 8222|      0|#line 8223 "mrbgems/mruby-compiler/core/y.tab.c"
 8223|      0|    break;
 8224|       |
 8225|      0|  case 274: /* opt_block_arg: comma block_arg  */
  ------------------
  |  Branch (8225:3): [True: 0, False: 12.5M]
  ------------------
 8226|      0|#line 2622 "mrbgems/mruby-compiler/core/parse.y"
 8227|      0|                    {
 8228|      0|                      (yyval.nd) = (yyvsp[0].nd);
 8229|      0|                    }
 8230|      0|#line 8231 "mrbgems/mruby-compiler/core/y.tab.c"
 8231|      0|    break;
 8232|       |
 8233|  78.8k|  case 275: /* opt_block_arg: none  */
  ------------------
  |  Branch (8233:3): [True: 78.8k, False: 12.4M]
  ------------------
 8234|  78.8k|#line 2626 "mrbgems/mruby-compiler/core/parse.y"
 8235|  78.8k|                    {
 8236|  78.8k|                      (yyval.nd) = 0;
 8237|  78.8k|                    }
 8238|  78.8k|#line 8239 "mrbgems/mruby-compiler/core/y.tab.c"
 8239|  78.8k|    break;
 8240|       |
 8241|   134k|  case 277: /* args: arg  */
  ------------------
  |  Branch (8241:3): [True: 134k, False: 12.4M]
  ------------------
 8242|   134k|#line 2635 "mrbgems/mruby-compiler/core/parse.y"
 8243|   134k|                    {
 8244|   134k|                      void_expr_error(p, (yyvsp[0].nd));
 8245|   134k|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|   134k|#define list1(a) list1_gen(p, (a))
  ------------------
 8246|   134k|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|   134k|#define NODE_LINENO(c,n) do {\
  |  |  126|   134k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 134k, False: 0]
  |  |  ------------------
  |  |  127|   134k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|   134k|     (c)->lineno = (n)->lineno;\
  |  |  129|   134k|  }\
  |  |  130|   134k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8247|   134k|                    }
 8248|   134k|#line 8249 "mrbgems/mruby-compiler/core/y.tab.c"
 8249|   134k|    break;
 8250|       |
 8251|      0|  case 278: /* args: "*"  */
  ------------------
  |  Branch (8251:3): [True: 0, False: 12.5M]
  ------------------
 8252|      0|#line 2641 "mrbgems/mruby-compiler/core/parse.y"
 8253|      0|                    {
 8254|      0|                      (yyval.nd) = list1(new_splat(p, new_lvar(p, intern_op(mul))));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8255|      0|                    }
 8256|      0|#line 8257 "mrbgems/mruby-compiler/core/y.tab.c"
 8257|      0|    break;
 8258|       |
 8259|      0|  case 279: /* args: "*" arg  */
  ------------------
  |  Branch (8259:3): [True: 0, False: 12.5M]
  ------------------
 8260|      0|#line 2645 "mrbgems/mruby-compiler/core/parse.y"
 8261|      0|                    {
 8262|      0|                      (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8263|      0|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|      0|#define NODE_LINENO(c,n) do {\
  |  |  126|      0|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8264|      0|                    }
 8265|      0|#line 8266 "mrbgems/mruby-compiler/core/y.tab.c"
 8266|      0|    break;
 8267|       |
 8268|   238k|  case 280: /* args: args comma arg  */
  ------------------
  |  Branch (8268:3): [True: 238k, False: 12.3M]
  ------------------
 8269|   238k|#line 2650 "mrbgems/mruby-compiler/core/parse.y"
 8270|   238k|                    {
 8271|   238k|                      void_expr_error(p, (yyvsp[0].nd));
 8272|   238k|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|   238k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|   238k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8273|   238k|                    }
 8274|   238k|#line 8275 "mrbgems/mruby-compiler/core/y.tab.c"
 8275|   238k|    break;
 8276|       |
 8277|      0|  case 281: /* args: args comma "*"  */
  ------------------
  |  Branch (8277:3): [True: 0, False: 12.5M]
  ------------------
 8278|      0|#line 2655 "mrbgems/mruby-compiler/core/parse.y"
 8279|      0|                    {
 8280|      0|                      (yyval.nd) = push((yyvsp[-2].nd), new_splat(p, new_lvar(p, intern_op(mul))));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8281|      0|                    }
 8282|      0|#line 8283 "mrbgems/mruby-compiler/core/y.tab.c"
 8283|      0|    break;
 8284|       |
 8285|      0|  case 282: /* args: args comma "*" arg  */
  ------------------
  |  Branch (8285:3): [True: 0, False: 12.5M]
  ------------------
 8286|      0|#line 2659 "mrbgems/mruby-compiler/core/parse.y"
 8287|      0|                    {
 8288|      0|                      (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8289|      0|                    }
 8290|      0|#line 8291 "mrbgems/mruby-compiler/core/y.tab.c"
 8291|      0|    break;
 8292|       |
 8293|      0|  case 283: /* mrhs: args comma arg  */
  ------------------
  |  Branch (8293:3): [True: 0, False: 12.5M]
  ------------------
 8294|      0|#line 2665 "mrbgems/mruby-compiler/core/parse.y"
 8295|      0|                    {
 8296|      0|                      void_expr_error(p, (yyvsp[0].nd));
 8297|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8298|      0|                    }
 8299|      0|#line 8300 "mrbgems/mruby-compiler/core/y.tab.c"
 8300|      0|    break;
 8301|       |
 8302|      0|  case 284: /* mrhs: args comma "*" arg  */
  ------------------
  |  Branch (8302:3): [True: 0, False: 12.5M]
  ------------------
 8303|      0|#line 2670 "mrbgems/mruby-compiler/core/parse.y"
 8304|      0|                    {
 8305|      0|                      (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 8306|      0|                    }
 8307|      0|#line 8308 "mrbgems/mruby-compiler/core/y.tab.c"
 8308|      0|    break;
 8309|       |
 8310|      0|  case 285: /* mrhs: "*" arg  */
  ------------------
  |  Branch (8310:3): [True: 0, False: 12.5M]
  ------------------
 8311|      0|#line 2674 "mrbgems/mruby-compiler/core/parse.y"
 8312|      0|                    {
 8313|      0|                      (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8314|      0|                    }
 8315|      0|#line 8316 "mrbgems/mruby-compiler/core/y.tab.c"
 8316|      0|    break;
 8317|       |
 8318|      0|  case 293: /* primary: "numbered parameter"  */
  ------------------
  |  Branch (8318:3): [True: 0, False: 12.5M]
  ------------------
 8319|      0|#line 2687 "mrbgems/mruby-compiler/core/parse.y"
 8320|      0|                    {
 8321|      0|                      (yyval.nd) = new_nvar(p, (yyvsp[0].num));
 8322|      0|                    }
 8323|      0|#line 8324 "mrbgems/mruby-compiler/core/y.tab.c"
 8324|      0|    break;
 8325|       |
 8326|      0|  case 294: /* primary: "method"  */
  ------------------
  |  Branch (8326:3): [True: 0, False: 12.5M]
  ------------------
 8327|      0|#line 2691 "mrbgems/mruby-compiler/core/parse.y"
 8328|      0|                    {
 8329|      0|                      (yyval.nd) = new_fcall(p, (yyvsp[0].id), 0);
 8330|      0|                    }
 8331|      0|#line 8332 "mrbgems/mruby-compiler/core/y.tab.c"
 8332|      0|    break;
 8333|       |
 8334|  31.8k|  case 295: /* @8: %empty  */
  ------------------
  |  Branch (8334:3): [True: 31.8k, False: 12.5M]
  ------------------
 8335|  31.8k|#line 2695 "mrbgems/mruby-compiler/core/parse.y"
 8336|  31.8k|                    {
 8337|  31.8k|                      (yyval.stack) = p->cmdarg_stack;
 8338|  31.8k|                      p->cmdarg_stack = 0;
 8339|  31.8k|                    }
 8340|  31.8k|#line 8341 "mrbgems/mruby-compiler/core/y.tab.c"
 8341|  31.8k|    break;
 8342|       |
 8343|  31.8k|  case 296: /* primary: keyword_begin @8 bodystmt keyword_end  */
  ------------------
  |  Branch (8343:3): [True: 31.8k, False: 12.5M]
  ------------------
 8344|  31.8k|#line 2701 "mrbgems/mruby-compiler/core/parse.y"
 8345|  31.8k|                    {
 8346|  31.8k|                      p->cmdarg_stack = (yyvsp[-2].stack);
 8347|  31.8k|                      (yyval.nd) = (yyvsp[-1].nd);
 8348|  31.8k|                    }
 8349|  31.8k|#line 8350 "mrbgems/mruby-compiler/core/y.tab.c"
 8350|  31.8k|    break;
 8351|       |
 8352|      0|  case 297: /* @9: %empty  */
  ------------------
  |  Branch (8352:3): [True: 0, False: 12.5M]
  ------------------
 8353|      0|#line 2706 "mrbgems/mruby-compiler/core/parse.y"
 8354|      0|                    {
 8355|      0|                      (yyval.stack) = p->cmdarg_stack;
 8356|      0|                      p->cmdarg_stack = 0;
 8357|      0|                    }
 8358|      0|#line 8359 "mrbgems/mruby-compiler/core/y.tab.c"
 8359|      0|    break;
 8360|       |
 8361|      0|  case 298: /* $@10: %empty  */
  ------------------
  |  Branch (8361:3): [True: 0, False: 12.5M]
  ------------------
 8362|      0|#line 2710 "mrbgems/mruby-compiler/core/parse.y"
 8363|      0|                       {p->lstate = EXPR_ENDARG;}
 8364|      0|#line 8365 "mrbgems/mruby-compiler/core/y.tab.c"
 8365|      0|    break;
 8366|       |
 8367|      0|  case 299: /* primary: "(" @9 stmt $@10 rparen  */
  ------------------
  |  Branch (8367:3): [True: 0, False: 12.5M]
  ------------------
 8368|      0|#line 2711 "mrbgems/mruby-compiler/core/parse.y"
 8369|      0|                    {
 8370|      0|                      p->cmdarg_stack = (yyvsp[-3].stack);
 8371|      0|                      (yyval.nd) = (yyvsp[-2].nd);
 8372|      0|                    }
 8373|      0|#line 8374 "mrbgems/mruby-compiler/core/y.tab.c"
 8374|      0|    break;
 8375|       |
 8376|      0|  case 300: /* $@11: %empty  */
  ------------------
  |  Branch (8376:3): [True: 0, False: 12.5M]
  ------------------
 8377|      0|#line 2715 "mrbgems/mruby-compiler/core/parse.y"
 8378|      0|                              {p->lstate = EXPR_ENDARG;}
 8379|      0|#line 8380 "mrbgems/mruby-compiler/core/y.tab.c"
 8380|      0|    break;
 8381|       |
 8382|      0|  case 301: /* primary: "(" $@11 rparen  */
  ------------------
  |  Branch (8382:3): [True: 0, False: 12.5M]
  ------------------
 8383|      0|#line 2716 "mrbgems/mruby-compiler/core/parse.y"
 8384|      0|                    {
 8385|      0|                      (yyval.nd) = new_nil(p);
 8386|      0|                    }
 8387|      0|#line 8388 "mrbgems/mruby-compiler/core/y.tab.c"
 8388|      0|    break;
 8389|       |
 8390|   183k|  case 302: /* primary: tLPAREN compstmt ')'  */
  ------------------
  |  Branch (8390:3): [True: 183k, False: 12.3M]
  ------------------
 8391|   183k|#line 2720 "mrbgems/mruby-compiler/core/parse.y"
 8392|   183k|                    {
 8393|   183k|                      (yyval.nd) = (yyvsp[-1].nd);
 8394|   183k|                    }
 8395|   183k|#line 8396 "mrbgems/mruby-compiler/core/y.tab.c"
 8396|   183k|    break;
 8397|       |
 8398|  3.08k|  case 303: /* primary: primary_value "::" "constant"  */
  ------------------
  |  Branch (8398:3): [True: 3.08k, False: 12.5M]
  ------------------
 8399|  3.08k|#line 2724 "mrbgems/mruby-compiler/core/parse.y"
 8400|  3.08k|                    {
 8401|  3.08k|                      (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
 8402|  3.08k|                    }
 8403|  3.08k|#line 8404 "mrbgems/mruby-compiler/core/y.tab.c"
 8404|  3.08k|    break;
 8405|       |
 8406|      0|  case 304: /* primary: tCOLON3 "constant"  */
  ------------------
  |  Branch (8406:3): [True: 0, False: 12.5M]
  ------------------
 8407|      0|#line 2728 "mrbgems/mruby-compiler/core/parse.y"
 8408|      0|                    {
 8409|      0|                      (yyval.nd) = new_colon3(p, (yyvsp[0].id));
 8410|      0|                    }
 8411|      0|#line 8412 "mrbgems/mruby-compiler/core/y.tab.c"
 8412|      0|    break;
 8413|       |
 8414|  55.7k|  case 305: /* primary: "[" aref_args ']'  */
  ------------------
  |  Branch (8414:3): [True: 55.7k, False: 12.4M]
  ------------------
 8415|  55.7k|#line 2732 "mrbgems/mruby-compiler/core/parse.y"
 8416|  55.7k|                    {
 8417|  55.7k|                      (yyval.nd) = new_array(p, (yyvsp[-1].nd));
 8418|  55.7k|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|  55.7k|#define NODE_LINENO(c,n) do {\
  |  |  126|  55.7k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 55.7k, False: 0]
  |  |  ------------------
  |  |  127|  55.7k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  55.7k|     (c)->lineno = (n)->lineno;\
  |  |  129|  55.7k|  }\
  |  |  130|  55.7k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8419|  55.7k|                    }
 8420|  55.7k|#line 8421 "mrbgems/mruby-compiler/core/y.tab.c"
 8421|  55.7k|    break;
 8422|       |
 8423|  3.61k|  case 306: /* primary: tLBRACE assoc_list '}'  */
  ------------------
  |  Branch (8423:3): [True: 3.61k, False: 12.5M]
  ------------------
 8424|  3.61k|#line 2737 "mrbgems/mruby-compiler/core/parse.y"
 8425|  3.61k|                    {
 8426|  3.61k|                      (yyval.nd) = new_hash(p, (yyvsp[-1].nd));
 8427|  3.61k|                      NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
  ------------------
  |  |  125|  3.61k|#define NODE_LINENO(c,n) do {\
  |  |  126|  3.61k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 3.61k, False: 0]
  |  |  ------------------
  |  |  127|  3.61k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  3.61k|     (c)->lineno = (n)->lineno;\
  |  |  129|  3.61k|  }\
  |  |  130|  3.61k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8428|  3.61k|                    }
 8429|  3.61k|#line 8430 "mrbgems/mruby-compiler/core/y.tab.c"
 8430|  3.61k|    break;
 8431|       |
 8432|      0|  case 307: /* primary: keyword_return  */
  ------------------
  |  Branch (8432:3): [True: 0, False: 12.5M]
  ------------------
 8433|      0|#line 2742 "mrbgems/mruby-compiler/core/parse.y"
 8434|      0|                    {
 8435|      0|                      (yyval.nd) = new_return(p, 0);
 8436|      0|                    }
 8437|      0|#line 8438 "mrbgems/mruby-compiler/core/y.tab.c"
 8438|      0|    break;
 8439|       |
 8440|      0|  case 308: /* primary: keyword_yield opt_paren_args  */
  ------------------
  |  Branch (8440:3): [True: 0, False: 12.5M]
  ------------------
 8441|      0|#line 2746 "mrbgems/mruby-compiler/core/parse.y"
 8442|      0|                    {
 8443|      0|                      (yyval.nd) = new_yield(p, (yyvsp[0].nd));
 8444|      0|                    }
 8445|      0|#line 8446 "mrbgems/mruby-compiler/core/y.tab.c"
 8446|      0|    break;
 8447|       |
 8448|      0|  case 309: /* primary: keyword_not '(' expr rparen  */
  ------------------
  |  Branch (8448:3): [True: 0, False: 12.5M]
  ------------------
 8449|      0|#line 2750 "mrbgems/mruby-compiler/core/parse.y"
 8450|      0|                    {
 8451|      0|                      (yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!");
 8452|      0|                    }
 8453|      0|#line 8454 "mrbgems/mruby-compiler/core/y.tab.c"
 8454|      0|    break;
 8455|       |
 8456|      0|  case 310: /* primary: keyword_not '(' rparen  */
  ------------------
  |  Branch (8456:3): [True: 0, False: 12.5M]
  ------------------
 8457|      0|#line 2754 "mrbgems/mruby-compiler/core/parse.y"
 8458|      0|                    {
 8459|      0|                      (yyval.nd) = call_uni_op(p, new_nil(p), "!");
 8460|      0|                    }
 8461|      0|#line 8462 "mrbgems/mruby-compiler/core/y.tab.c"
 8462|      0|    break;
 8463|       |
 8464|      0|  case 311: /* primary: operation brace_block  */
  ------------------
  |  Branch (8464:3): [True: 0, False: 12.5M]
  ------------------
 8465|      0|#line 2758 "mrbgems/mruby-compiler/core/parse.y"
 8466|      0|                    {
 8467|      0|                      (yyval.nd) = new_fcall(p, (yyvsp[-1].id), new_callargs(p, 0, 0, (yyvsp[0].nd)));
 8468|      0|                    }
 8469|      0|#line 8470 "mrbgems/mruby-compiler/core/y.tab.c"
 8470|      0|    break;
 8471|       |
 8472|      0|  case 313: /* primary: method_call brace_block  */
  ------------------
  |  Branch (8472:3): [True: 0, False: 12.5M]
  ------------------
 8473|      0|#line 2763 "mrbgems/mruby-compiler/core/parse.y"
 8474|      0|                    {
 8475|      0|                      call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 8476|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 8477|      0|                    }
 8478|      0|#line 8479 "mrbgems/mruby-compiler/core/y.tab.c"
 8479|      0|    break;
 8480|       |
 8481|      0|  case 314: /* @12: %empty  */
  ------------------
  |  Branch (8481:3): [True: 0, False: 12.5M]
  ------------------
 8482|      0|#line 2768 "mrbgems/mruby-compiler/core/parse.y"
 8483|      0|                    {
 8484|      0|                      local_nest(p);
 8485|      0|                      nvars_nest(p);
 8486|      0|                      (yyval.num) = p->lpar_beg;
 8487|      0|                      p->lpar_beg = ++p->paren_nest;
 8488|      0|                    }
 8489|      0|#line 8490 "mrbgems/mruby-compiler/core/y.tab.c"
 8490|      0|    break;
 8491|       |
 8492|      0|  case 315: /* @13: %empty  */
  ------------------
  |  Branch (8492:3): [True: 0, False: 12.5M]
  ------------------
 8493|      0|#line 2775 "mrbgems/mruby-compiler/core/parse.y"
 8494|      0|                    {
 8495|      0|                      (yyval.stack) = p->cmdarg_stack;
 8496|      0|                      p->cmdarg_stack = 0;
 8497|      0|                    }
 8498|      0|#line 8499 "mrbgems/mruby-compiler/core/y.tab.c"
 8499|      0|    break;
 8500|       |
 8501|      0|  case 316: /* primary: "->" @12 f_larglist @13 lambda_body  */
  ------------------
  |  Branch (8501:3): [True: 0, False: 12.5M]
  ------------------
 8502|      0|#line 2780 "mrbgems/mruby-compiler/core/parse.y"
 8503|      0|                    {
 8504|      0|                      p->lpar_beg = (yyvsp[-3].num);
 8505|      0|                      (yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd));
 8506|      0|                      local_unnest(p);
 8507|      0|                      nvars_unnest(p);
 8508|      0|                      p->cmdarg_stack = (yyvsp[-1].stack);
 8509|      0|                      CMDARG_LEXPOP();
  ------------------
  |  |  121|      0|#define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack)
  |  |  ------------------
  |  |  |  |  111|      0|#define BITSTACK_LEXPOP(stack)  ((stack) = ((stack) >> 1) | ((stack) & 1))
  |  |  ------------------
  ------------------
 8510|      0|                    }
 8511|      0|#line 8512 "mrbgems/mruby-compiler/core/y.tab.c"
 8512|      0|    break;
 8513|       |
 8514|  17.5k|  case 317: /* primary: keyword_if expr_value then compstmt if_tail keyword_end  */
  ------------------
  |  Branch (8514:3): [True: 17.5k, False: 12.5M]
  ------------------
 8515|  17.5k|#line 2792 "mrbgems/mruby-compiler/core/parse.y"
 8516|  17.5k|                    {
 8517|  17.5k|                      (yyval.nd) = new_if(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
 8518|  17.5k|                      SET_LINENO((yyval.nd), (yyvsp[-5].num));
  ------------------
  |  |  124|  17.5k|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8519|  17.5k|                    }
 8520|  17.5k|#line 8521 "mrbgems/mruby-compiler/core/y.tab.c"
 8521|  17.5k|    break;
 8522|       |
 8523|      0|  case 318: /* primary: keyword_unless expr_value then compstmt opt_else keyword_end  */
  ------------------
  |  Branch (8523:3): [True: 0, False: 12.5M]
  ------------------
 8524|      0|#line 2800 "mrbgems/mruby-compiler/core/parse.y"
 8525|      0|                    {
 8526|      0|                      (yyval.nd) = new_unless(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
 8527|      0|                      SET_LINENO((yyval.nd), (yyvsp[-5].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8528|      0|                    }
 8529|      0|#line 8530 "mrbgems/mruby-compiler/core/y.tab.c"
 8530|      0|    break;
 8531|       |
 8532|      0|  case 319: /* $@14: %empty  */
  ------------------
  |  Branch (8532:3): [True: 0, False: 12.5M]
  ------------------
 8533|      0|#line 2804 "mrbgems/mruby-compiler/core/parse.y"
 8534|      0|                                {COND_PUSH(1);}
  ------------------
  |  |  114|      0|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
 8535|      0|#line 8536 "mrbgems/mruby-compiler/core/y.tab.c"
 8536|      0|    break;
 8537|       |
 8538|      0|  case 320: /* $@15: %empty  */
  ------------------
  |  Branch (8538:3): [True: 0, False: 12.5M]
  ------------------
 8539|      0|#line 2804 "mrbgems/mruby-compiler/core/parse.y"
 8540|      0|                                                              {COND_POP();}
  ------------------
  |  |  115|      0|#define COND_POP()      BITSTACK_POP(p->cond_stack)
  |  |  ------------------
  |  |  |  |  110|      0|#define BITSTACK_POP(stack)     ((stack) = (stack) >> 1)
  |  |  ------------------
  ------------------
 8541|      0|#line 8542 "mrbgems/mruby-compiler/core/y.tab.c"
 8542|      0|    break;
 8543|       |
 8544|      0|  case 321: /* primary: keyword_while $@14 expr_value do $@15 compstmt keyword_end  */
  ------------------
  |  Branch (8544:3): [True: 0, False: 12.5M]
  ------------------
 8545|      0|#line 2807 "mrbgems/mruby-compiler/core/parse.y"
 8546|      0|                    {
 8547|      0|                      (yyval.nd) = new_while(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
 8548|      0|                      SET_LINENO((yyval.nd), (yyvsp[-6].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8549|      0|                    }
 8550|      0|#line 8551 "mrbgems/mruby-compiler/core/y.tab.c"
 8551|      0|    break;
 8552|       |
 8553|      0|  case 322: /* $@16: %empty  */
  ------------------
  |  Branch (8553:3): [True: 0, False: 12.5M]
  ------------------
 8554|      0|#line 2811 "mrbgems/mruby-compiler/core/parse.y"
 8555|      0|                                {COND_PUSH(1);}
  ------------------
  |  |  114|      0|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
 8556|      0|#line 8557 "mrbgems/mruby-compiler/core/y.tab.c"
 8557|      0|    break;
 8558|       |
 8559|      0|  case 323: /* $@17: %empty  */
  ------------------
  |  Branch (8559:3): [True: 0, False: 12.5M]
  ------------------
 8560|      0|#line 2811 "mrbgems/mruby-compiler/core/parse.y"
 8561|      0|                                                              {COND_POP();}
  ------------------
  |  |  115|      0|#define COND_POP()      BITSTACK_POP(p->cond_stack)
  |  |  ------------------
  |  |  |  |  110|      0|#define BITSTACK_POP(stack)     ((stack) = (stack) >> 1)
  |  |  ------------------
  ------------------
 8562|      0|#line 8563 "mrbgems/mruby-compiler/core/y.tab.c"
 8563|      0|    break;
 8564|       |
 8565|      0|  case 324: /* primary: keyword_until $@16 expr_value do $@17 compstmt keyword_end  */
  ------------------
  |  Branch (8565:3): [True: 0, False: 12.5M]
  ------------------
 8566|      0|#line 2814 "mrbgems/mruby-compiler/core/parse.y"
 8567|      0|                    {
 8568|      0|                      (yyval.nd) = new_until(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
 8569|      0|                      SET_LINENO((yyval.nd), (yyvsp[-6].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8570|      0|                    }
 8571|      0|#line 8572 "mrbgems/mruby-compiler/core/y.tab.c"
 8572|      0|    break;
 8573|       |
 8574|      0|  case 325: /* primary: keyword_case expr_value opt_terms case_body keyword_end  */
  ------------------
  |  Branch (8574:3): [True: 0, False: 12.5M]
  ------------------
 8575|      0|#line 2821 "mrbgems/mruby-compiler/core/parse.y"
 8576|      0|                    {
 8577|      0|                      (yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
 8578|      0|                    }
 8579|      0|#line 8580 "mrbgems/mruby-compiler/core/y.tab.c"
 8580|      0|    break;
 8581|       |
 8582|      0|  case 326: /* primary: keyword_case opt_terms case_body keyword_end  */
  ------------------
  |  Branch (8582:3): [True: 0, False: 12.5M]
  ------------------
 8583|      0|#line 2825 "mrbgems/mruby-compiler/core/parse.y"
 8584|      0|                    {
 8585|      0|                      (yyval.nd) = new_case(p, 0, (yyvsp[-1].nd));
 8586|      0|                    }
 8587|      0|#line 8588 "mrbgems/mruby-compiler/core/y.tab.c"
 8588|      0|    break;
 8589|       |
 8590|      0|  case 327: /* $@18: %empty  */
  ------------------
  |  Branch (8590:3): [True: 0, False: 12.5M]
  ------------------
 8591|      0|#line 2829 "mrbgems/mruby-compiler/core/parse.y"
 8592|      0|                  {COND_PUSH(1);}
  ------------------
  |  |  114|      0|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
 8593|      0|#line 8594 "mrbgems/mruby-compiler/core/y.tab.c"
 8594|      0|    break;
 8595|       |
 8596|      0|  case 328: /* $@19: %empty  */
  ------------------
  |  Branch (8596:3): [True: 0, False: 12.5M]
  ------------------
 8597|      0|#line 2831 "mrbgems/mruby-compiler/core/parse.y"
 8598|      0|                  {COND_POP();}
  ------------------
  |  |  115|      0|#define COND_POP()      BITSTACK_POP(p->cond_stack)
  |  |  ------------------
  |  |  |  |  110|      0|#define BITSTACK_POP(stack)     ((stack) = (stack) >> 1)
  |  |  ------------------
  ------------------
 8599|      0|#line 8600 "mrbgems/mruby-compiler/core/y.tab.c"
 8600|      0|    break;
 8601|       |
 8602|      0|  case 329: /* primary: keyword_for for_var keyword_in $@18 expr_value do $@19 compstmt keyword_end  */
  ------------------
  |  Branch (8602:3): [True: 0, False: 12.5M]
  ------------------
 8603|      0|#line 2834 "mrbgems/mruby-compiler/core/parse.y"
 8604|      0|                    {
 8605|      0|                      (yyval.nd) = new_for(p, (yyvsp[-7].nd), (yyvsp[-4].nd), (yyvsp[-1].nd));
 8606|      0|                      SET_LINENO((yyval.nd), (yyvsp[-8].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8607|      0|                    }
 8608|      0|#line 8609 "mrbgems/mruby-compiler/core/y.tab.c"
 8609|      0|    break;
 8610|       |
 8611|      0|  case 330: /* @20: %empty  */
  ------------------
  |  Branch (8611:3): [True: 0, False: 12.5M]
  ------------------
 8612|      0|#line 2840 "mrbgems/mruby-compiler/core/parse.y"
 8613|      0|                    {
 8614|      0|                      if (p->in_def || p->in_single)
  ------------------
  |  Branch (8614:27): [True: 0, False: 0]
  |  Branch (8614:40): [True: 0, False: 0]
  ------------------
 8615|      0|                        yyerror(p, "class definition in method body");
 8616|      0|                      (yyval.nd) = local_switch(p);
 8617|      0|                      nvars_block(p);
 8618|      0|                    }
 8619|      0|#line 8620 "mrbgems/mruby-compiler/core/y.tab.c"
 8620|      0|    break;
 8621|       |
 8622|      0|  case 331: /* primary: keyword_class cpath superclass @20 bodystmt keyword_end  */
  ------------------
  |  Branch (8622:3): [True: 0, False: 12.5M]
  ------------------
 8623|      0|#line 2848 "mrbgems/mruby-compiler/core/parse.y"
 8624|      0|                    {
 8625|      0|                      (yyval.nd) = new_class(p, (yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd));
 8626|      0|                      SET_LINENO((yyval.nd), (yyvsp[-5].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8627|      0|                      local_resume(p, (yyvsp[-2].nd));
 8628|      0|                      nvars_unnest(p);
 8629|      0|                    }
 8630|      0|#line 8631 "mrbgems/mruby-compiler/core/y.tab.c"
 8631|      0|    break;
 8632|       |
 8633|      0|  case 332: /* @21: %empty  */
  ------------------
  |  Branch (8633:3): [True: 0, False: 12.5M]
  ------------------
 8634|      0|#line 2856 "mrbgems/mruby-compiler/core/parse.y"
 8635|      0|                    {
 8636|      0|                      (yyval.num) = p->in_def;
 8637|      0|                      p->in_def = 0;
 8638|      0|                    }
 8639|      0|#line 8640 "mrbgems/mruby-compiler/core/y.tab.c"
 8640|      0|    break;
 8641|       |
 8642|      0|  case 333: /* @22: %empty  */
  ------------------
  |  Branch (8642:3): [True: 0, False: 12.5M]
  ------------------
 8643|      0|#line 2861 "mrbgems/mruby-compiler/core/parse.y"
 8644|      0|                    {
 8645|      0|                      (yyval.nd) = cons(local_switch(p), nint(p->in_single));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 8646|      0|                      nvars_block(p);
 8647|      0|                      p->in_single = 0;
 8648|      0|                    }
 8649|      0|#line 8650 "mrbgems/mruby-compiler/core/y.tab.c"
 8650|      0|    break;
 8651|       |
 8652|      0|  case 334: /* primary: keyword_class "<<" expr @21 term @22 bodystmt keyword_end  */
  ------------------
  |  Branch (8652:3): [True: 0, False: 12.5M]
  ------------------
 8653|      0|#line 2868 "mrbgems/mruby-compiler/core/parse.y"
 8654|      0|                    {
 8655|      0|                      (yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd));
 8656|      0|                      SET_LINENO((yyval.nd), (yyvsp[-7].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8657|      0|                      local_resume(p, (yyvsp[-2].nd)->car);
 8658|      0|                      nvars_unnest(p);
 8659|      0|                      p->in_def = (yyvsp[-4].num);
 8660|      0|                      p->in_single = intn((yyvsp[-2].nd)->cdr);
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
 8661|      0|                    }
 8662|      0|#line 8663 "mrbgems/mruby-compiler/core/y.tab.c"
 8663|      0|    break;
 8664|       |
 8665|      0|  case 335: /* @23: %empty  */
  ------------------
  |  Branch (8665:3): [True: 0, False: 12.5M]
  ------------------
 8666|      0|#line 2878 "mrbgems/mruby-compiler/core/parse.y"
 8667|      0|                    {
 8668|      0|                      if (p->in_def || p->in_single)
  ------------------
  |  Branch (8668:27): [True: 0, False: 0]
  |  Branch (8668:40): [True: 0, False: 0]
  ------------------
 8669|      0|                        yyerror(p, "module definition in method body");
 8670|      0|                      (yyval.nd) = local_switch(p);
 8671|      0|                      nvars_block(p);
 8672|      0|                    }
 8673|      0|#line 8674 "mrbgems/mruby-compiler/core/y.tab.c"
 8674|      0|    break;
 8675|       |
 8676|      0|  case 336: /* primary: keyword_module cpath @23 bodystmt keyword_end  */
  ------------------
  |  Branch (8676:3): [True: 0, False: 12.5M]
  ------------------
 8677|      0|#line 2886 "mrbgems/mruby-compiler/core/parse.y"
 8678|      0|                    {
 8679|      0|                      (yyval.nd) = new_module(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
 8680|      0|                      SET_LINENO((yyval.nd), (yyvsp[-4].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 8681|      0|                      local_resume(p, (yyvsp[-2].nd));
 8682|      0|                      nvars_unnest(p);
 8683|      0|                    }
 8684|      0|#line 8685 "mrbgems/mruby-compiler/core/y.tab.c"
 8685|      0|    break;
 8686|       |
 8687|  1.74k|  case 337: /* primary: defn_head f_arglist bodystmt keyword_end  */
  ------------------
  |  Branch (8687:3): [True: 1.74k, False: 12.5M]
  ------------------
 8688|  1.74k|#line 2896 "mrbgems/mruby-compiler/core/parse.y"
 8689|  1.74k|                    {
 8690|  1.74k|                      (yyval.nd) = (yyvsp[-3].nd);
 8691|  1.74k|                      defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
 8692|  1.74k|                      nvars_unnest(p);
 8693|  1.74k|                      p->in_def--;
 8694|  1.74k|                    }
 8695|  1.74k|#line 8696 "mrbgems/mruby-compiler/core/y.tab.c"
 8696|  1.74k|    break;
 8697|       |
 8698|      0|  case 338: /* primary: defs_head f_arglist bodystmt keyword_end  */
  ------------------
  |  Branch (8698:3): [True: 0, False: 12.5M]
  ------------------
 8699|      0|#line 2906 "mrbgems/mruby-compiler/core/parse.y"
 8700|      0|                    {
 8701|      0|                      (yyval.nd) = (yyvsp[-3].nd);
 8702|      0|                      defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
 8703|      0|                      nvars_unnest(p);
 8704|      0|                      p->in_def--;
 8705|      0|                      p->in_single--;
 8706|      0|                    }
 8707|      0|#line 8708 "mrbgems/mruby-compiler/core/y.tab.c"
 8708|      0|    break;
 8709|       |
 8710|      0|  case 339: /* primary: keyword_break  */
  ------------------
  |  Branch (8710:3): [True: 0, False: 12.5M]
  ------------------
 8711|      0|#line 2914 "mrbgems/mruby-compiler/core/parse.y"
 8712|      0|                    {
 8713|      0|                      (yyval.nd) = new_break(p, 0);
 8714|      0|                    }
 8715|      0|#line 8716 "mrbgems/mruby-compiler/core/y.tab.c"
 8716|      0|    break;
 8717|       |
 8718|      0|  case 340: /* primary: keyword_next  */
  ------------------
  |  Branch (8718:3): [True: 0, False: 12.5M]
  ------------------
 8719|      0|#line 2918 "mrbgems/mruby-compiler/core/parse.y"
 8720|      0|                    {
 8721|      0|                      (yyval.nd) = new_next(p, 0);
 8722|      0|                    }
 8723|      0|#line 8724 "mrbgems/mruby-compiler/core/y.tab.c"
 8724|      0|    break;
 8725|       |
 8726|      0|  case 341: /* primary: keyword_redo  */
  ------------------
  |  Branch (8726:3): [True: 0, False: 12.5M]
  ------------------
 8727|      0|#line 2922 "mrbgems/mruby-compiler/core/parse.y"
 8728|      0|                    {
 8729|      0|                      (yyval.nd) = new_redo(p);
 8730|      0|                    }
 8731|      0|#line 8732 "mrbgems/mruby-compiler/core/y.tab.c"
 8732|      0|    break;
 8733|       |
 8734|      0|  case 342: /* primary: keyword_retry  */
  ------------------
  |  Branch (8734:3): [True: 0, False: 12.5M]
  ------------------
 8735|      0|#line 2926 "mrbgems/mruby-compiler/core/parse.y"
 8736|      0|                    {
 8737|      0|                      (yyval.nd) = new_retry(p);
 8738|      0|                    }
 8739|      0|#line 8740 "mrbgems/mruby-compiler/core/y.tab.c"
 8740|      0|    break;
 8741|       |
 8742|  98.9k|  case 343: /* primary_value: primary  */
  ------------------
  |  Branch (8742:3): [True: 98.9k, False: 12.4M]
  ------------------
 8743|  98.9k|#line 2932 "mrbgems/mruby-compiler/core/parse.y"
 8744|  98.9k|                    {
 8745|  98.9k|                      (yyval.nd) = (yyvsp[0].nd);
 8746|  98.9k|                      if (!(yyval.nd)) (yyval.nd) = new_nil(p);
  ------------------
  |  Branch (8746:27): [True: 0, False: 98.9k]
  ------------------
 8747|  98.9k|                    }
 8748|  98.9k|#line 8749 "mrbgems/mruby-compiler/core/y.tab.c"
 8749|  98.9k|    break;
 8750|       |
 8751|      0|  case 350: /* if_tail: keyword_elsif expr_value then compstmt if_tail  */
  ------------------
  |  Branch (8751:3): [True: 0, False: 12.5M]
  ------------------
 8752|      0|#line 2951 "mrbgems/mruby-compiler/core/parse.y"
 8753|      0|                    {
 8754|      0|                      (yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd));
 8755|      0|                    }
 8756|      0|#line 8757 "mrbgems/mruby-compiler/core/y.tab.c"
 8757|      0|    break;
 8758|       |
 8759|  17.5k|  case 352: /* opt_else: keyword_else compstmt  */
  ------------------
  |  Branch (8759:3): [True: 17.5k, False: 12.5M]
  ------------------
 8760|  17.5k|#line 2958 "mrbgems/mruby-compiler/core/parse.y"
 8761|  17.5k|                    {
 8762|  17.5k|                      (yyval.nd) = (yyvsp[0].nd);
 8763|  17.5k|                    }
 8764|  17.5k|#line 8765 "mrbgems/mruby-compiler/core/y.tab.c"
 8765|  17.5k|    break;
 8766|       |
 8767|      0|  case 353: /* for_var: lhs  */
  ------------------
  |  Branch (8767:3): [True: 0, False: 12.5M]
  ------------------
 8768|      0|#line 2964 "mrbgems/mruby-compiler/core/parse.y"
 8769|      0|                    {
 8770|      0|                      (yyval.nd) = list1(list1((yyvsp[0].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 8771|      0|                    }
 8772|      0|#line 8773 "mrbgems/mruby-compiler/core/y.tab.c"
 8773|      0|    break;
 8774|       |
 8775|      0|  case 355: /* f_margs: f_arg  */
  ------------------
  |  Branch (8775:3): [True: 0, False: 12.5M]
  ------------------
 8776|      0|#line 2971 "mrbgems/mruby-compiler/core/parse.y"
 8777|      0|                    {
 8778|      0|                      (yyval.nd) = list3((yyvsp[0].nd),0,0);
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8779|      0|                    }
 8780|      0|#line 8781 "mrbgems/mruby-compiler/core/y.tab.c"
 8781|      0|    break;
 8782|       |
 8783|      0|  case 356: /* f_margs: f_arg ',' "*" f_norm_arg  */
  ------------------
  |  Branch (8783:3): [True: 0, False: 12.5M]
  ------------------
 8784|      0|#line 2975 "mrbgems/mruby-compiler/core/parse.y"
 8785|      0|                    {
 8786|      0|                      (yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0);
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8787|      0|                    }
 8788|      0|#line 8789 "mrbgems/mruby-compiler/core/y.tab.c"
 8789|      0|    break;
 8790|       |
 8791|      0|  case 357: /* f_margs: f_arg ',' "*" f_norm_arg ',' f_arg  */
  ------------------
  |  Branch (8791:3): [True: 0, False: 12.5M]
  ------------------
 8792|      0|#line 2979 "mrbgems/mruby-compiler/core/parse.y"
 8793|      0|                    {
 8794|      0|                      (yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8795|      0|                    }
 8796|      0|#line 8797 "mrbgems/mruby-compiler/core/y.tab.c"
 8797|      0|    break;
 8798|       |
 8799|      0|  case 358: /* f_margs: f_arg ',' "*"  */
  ------------------
  |  Branch (8799:3): [True: 0, False: 12.5M]
  ------------------
 8800|      0|#line 2983 "mrbgems/mruby-compiler/core/parse.y"
 8801|      0|                    {
 8802|      0|                      local_add_f(p, intern_op(mul));
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8803|      0|                      (yyval.nd) = list3((yyvsp[-2].nd), nint(-1), 0);
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8804|      0|                    }
 8805|      0|#line 8806 "mrbgems/mruby-compiler/core/y.tab.c"
 8806|      0|    break;
 8807|       |
 8808|      0|  case 359: /* f_margs: f_arg ',' "*" ',' f_arg  */
  ------------------
  |  Branch (8808:3): [True: 0, False: 12.5M]
  ------------------
 8809|      0|#line 2988 "mrbgems/mruby-compiler/core/parse.y"
 8810|      0|                    {
 8811|      0|                      (yyval.nd) = list3((yyvsp[-4].nd), nint(-1), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8812|      0|                    }
 8813|      0|#line 8814 "mrbgems/mruby-compiler/core/y.tab.c"
 8814|      0|    break;
 8815|       |
 8816|      0|  case 360: /* f_margs: "*" f_norm_arg  */
  ------------------
  |  Branch (8816:3): [True: 0, False: 12.5M]
  ------------------
 8817|      0|#line 2992 "mrbgems/mruby-compiler/core/parse.y"
 8818|      0|                    {
 8819|      0|                      (yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0);
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8820|      0|                    }
 8821|      0|#line 8822 "mrbgems/mruby-compiler/core/y.tab.c"
 8822|      0|    break;
 8823|       |
 8824|      0|  case 361: /* f_margs: "*" f_norm_arg ',' f_arg  */
  ------------------
  |  Branch (8824:3): [True: 0, False: 12.5M]
  ------------------
 8825|      0|#line 2996 "mrbgems/mruby-compiler/core/parse.y"
 8826|      0|                    {
 8827|      0|                      (yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8828|      0|                    }
 8829|      0|#line 8830 "mrbgems/mruby-compiler/core/y.tab.c"
 8830|      0|    break;
 8831|       |
 8832|      0|  case 362: /* f_margs: "*"  */
  ------------------
  |  Branch (8832:3): [True: 0, False: 12.5M]
  ------------------
 8833|      0|#line 3000 "mrbgems/mruby-compiler/core/parse.y"
 8834|      0|                    {
 8835|      0|                      local_add_f(p, intern_op(mul));
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8836|      0|                      (yyval.nd) = list3(0, nint(-1), 0);
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8837|      0|                    }
 8838|      0|#line 8839 "mrbgems/mruby-compiler/core/y.tab.c"
 8839|      0|    break;
 8840|       |
 8841|      0|  case 363: /* $@24: %empty  */
  ------------------
  |  Branch (8841:3): [True: 0, False: 12.5M]
  ------------------
 8842|      0|#line 3005 "mrbgems/mruby-compiler/core/parse.y"
 8843|      0|                    {
 8844|      0|                      local_add_f(p, intern_op(mul));
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 8845|      0|                    }
 8846|      0|#line 8847 "mrbgems/mruby-compiler/core/y.tab.c"
 8847|      0|    break;
 8848|       |
 8849|      0|  case 364: /* f_margs: "*" ',' $@24 f_arg  */
  ------------------
  |  Branch (8849:3): [True: 0, False: 12.5M]
  ------------------
 8850|      0|#line 3009 "mrbgems/mruby-compiler/core/parse.y"
 8851|      0|                    {
 8852|      0|                      (yyval.nd) = list3(0, nint(-1), (yyvsp[0].nd));
  ------------------
  |  |  231|      0|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 8853|      0|                    }
 8854|      0|#line 8855 "mrbgems/mruby-compiler/core/y.tab.c"
 8855|      0|    break;
 8856|       |
 8857|      0|  case 365: /* block_args_tail: f_block_kwarg ',' f_kwrest opt_f_block_arg  */
  ------------------
  |  Branch (8857:3): [True: 0, False: 12.5M]
  ------------------
 8858|      0|#line 3015 "mrbgems/mruby-compiler/core/parse.y"
 8859|      0|                    {
 8860|      0|                      (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
 8861|      0|                    }
 8862|      0|#line 8863 "mrbgems/mruby-compiler/core/y.tab.c"
 8863|      0|    break;
 8864|       |
 8865|      0|  case 366: /* block_args_tail: f_block_kwarg opt_f_block_arg  */
  ------------------
  |  Branch (8865:3): [True: 0, False: 12.5M]
  ------------------
 8866|      0|#line 3019 "mrbgems/mruby-compiler/core/parse.y"
 8867|      0|                    {
 8868|      0|                      (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
 8869|      0|                    }
 8870|      0|#line 8871 "mrbgems/mruby-compiler/core/y.tab.c"
 8871|      0|    break;
 8872|       |
 8873|      0|  case 367: /* block_args_tail: f_kwrest opt_f_block_arg  */
  ------------------
  |  Branch (8873:3): [True: 0, False: 12.5M]
  ------------------
 8874|      0|#line 3023 "mrbgems/mruby-compiler/core/parse.y"
 8875|      0|                    {
 8876|      0|                      (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
 8877|      0|                    }
 8878|      0|#line 8879 "mrbgems/mruby-compiler/core/y.tab.c"
 8879|      0|    break;
 8880|       |
 8881|      0|  case 368: /* block_args_tail: f_block_arg  */
  ------------------
  |  Branch (8881:3): [True: 0, False: 12.5M]
  ------------------
 8882|      0|#line 3027 "mrbgems/mruby-compiler/core/parse.y"
 8883|      0|                    {
 8884|      0|                      (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
 8885|      0|                    }
 8886|      0|#line 8887 "mrbgems/mruby-compiler/core/y.tab.c"
 8887|      0|    break;
 8888|       |
 8889|      0|  case 369: /* opt_block_args_tail: ',' block_args_tail  */
  ------------------
  |  Branch (8889:3): [True: 0, False: 12.5M]
  ------------------
 8890|      0|#line 3033 "mrbgems/mruby-compiler/core/parse.y"
 8891|      0|                    {
 8892|      0|                      (yyval.nd) = (yyvsp[0].nd);
 8893|      0|                    }
 8894|      0|#line 8895 "mrbgems/mruby-compiler/core/y.tab.c"
 8895|      0|    break;
 8896|       |
 8897|      0|  case 370: /* opt_block_args_tail: %empty  */
  ------------------
  |  Branch (8897:3): [True: 0, False: 12.5M]
  ------------------
 8898|      0|#line 3037 "mrbgems/mruby-compiler/core/parse.y"
 8899|      0|                    {
 8900|      0|                      (yyval.nd) = new_args_tail(p, 0, 0, 0);
 8901|      0|                    }
 8902|      0|#line 8903 "mrbgems/mruby-compiler/core/y.tab.c"
 8903|      0|    break;
 8904|       |
 8905|      0|  case 371: /* block_param: f_arg ',' f_block_optarg ',' f_rest_arg opt_block_args_tail  */
  ------------------
  |  Branch (8905:3): [True: 0, False: 12.5M]
  ------------------
 8906|      0|#line 3043 "mrbgems/mruby-compiler/core/parse.y"
 8907|      0|                    {
 8908|      0|                      (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
 8909|      0|                    }
 8910|      0|#line 8911 "mrbgems/mruby-compiler/core/y.tab.c"
 8911|      0|    break;
 8912|       |
 8913|      0|  case 372: /* block_param: f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail  */
  ------------------
  |  Branch (8913:3): [True: 0, False: 12.5M]
  ------------------
 8914|      0|#line 3047 "mrbgems/mruby-compiler/core/parse.y"
 8915|      0|                    {
 8916|      0|                      (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
 8917|      0|                    }
 8918|      0|#line 8919 "mrbgems/mruby-compiler/core/y.tab.c"
 8919|      0|    break;
 8920|       |
 8921|      0|  case 373: /* block_param: f_arg ',' f_block_optarg opt_block_args_tail  */
  ------------------
  |  Branch (8921:3): [True: 0, False: 12.5M]
  ------------------
 8922|      0|#line 3051 "mrbgems/mruby-compiler/core/parse.y"
 8923|      0|                    {
 8924|      0|                      (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
 8925|      0|                    }
 8926|      0|#line 8927 "mrbgems/mruby-compiler/core/y.tab.c"
 8927|      0|    break;
 8928|       |
 8929|      0|  case 374: /* block_param: f_arg ',' f_block_optarg ',' f_arg opt_block_args_tail  */
  ------------------
  |  Branch (8929:3): [True: 0, False: 12.5M]
  ------------------
 8930|      0|#line 3055 "mrbgems/mruby-compiler/core/parse.y"
 8931|      0|                    {
 8932|      0|                      (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
 8933|      0|                    }
 8934|      0|#line 8935 "mrbgems/mruby-compiler/core/y.tab.c"
 8935|      0|    break;
 8936|       |
 8937|      0|  case 375: /* block_param: f_arg ',' f_rest_arg opt_block_args_tail  */
  ------------------
  |  Branch (8937:3): [True: 0, False: 12.5M]
  ------------------
 8938|      0|#line 3059 "mrbgems/mruby-compiler/core/parse.y"
 8939|      0|                    {
 8940|      0|                      (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
 8941|      0|                    }
 8942|      0|#line 8943 "mrbgems/mruby-compiler/core/y.tab.c"
 8943|      0|    break;
 8944|       |
 8945|      0|  case 376: /* block_param: f_arg ',' opt_block_args_tail  */
  ------------------
  |  Branch (8945:3): [True: 0, False: 12.5M]
  ------------------
 8946|      0|#line 3063 "mrbgems/mruby-compiler/core/parse.y"
 8947|      0|                    {
 8948|      0|                      (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd));
 8949|      0|                    }
 8950|      0|#line 8951 "mrbgems/mruby-compiler/core/y.tab.c"
 8951|      0|    break;
 8952|       |
 8953|      0|  case 377: /* block_param: f_arg ',' f_rest_arg ',' f_arg opt_block_args_tail  */
  ------------------
  |  Branch (8953:3): [True: 0, False: 12.5M]
  ------------------
 8954|      0|#line 3067 "mrbgems/mruby-compiler/core/parse.y"
 8955|      0|                    {
 8956|      0|                      (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
 8957|      0|                    }
 8958|      0|#line 8959 "mrbgems/mruby-compiler/core/y.tab.c"
 8959|      0|    break;
 8960|       |
 8961|      0|  case 378: /* block_param: f_arg opt_block_args_tail  */
  ------------------
  |  Branch (8961:3): [True: 0, False: 12.5M]
  ------------------
 8962|      0|#line 3071 "mrbgems/mruby-compiler/core/parse.y"
 8963|      0|                    {
 8964|      0|                      (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
 8965|      0|                    }
 8966|      0|#line 8967 "mrbgems/mruby-compiler/core/y.tab.c"
 8967|      0|    break;
 8968|       |
 8969|      0|  case 379: /* block_param: f_block_optarg ',' f_rest_arg opt_block_args_tail  */
  ------------------
  |  Branch (8969:3): [True: 0, False: 12.5M]
  ------------------
 8970|      0|#line 3075 "mrbgems/mruby-compiler/core/parse.y"
 8971|      0|                    {
 8972|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
 8973|      0|                    }
 8974|      0|#line 8975 "mrbgems/mruby-compiler/core/y.tab.c"
 8975|      0|    break;
 8976|       |
 8977|      0|  case 380: /* block_param: f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail  */
  ------------------
  |  Branch (8977:3): [True: 0, False: 12.5M]
  ------------------
 8978|      0|#line 3079 "mrbgems/mruby-compiler/core/parse.y"
 8979|      0|                    {
 8980|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
 8981|      0|                    }
 8982|      0|#line 8983 "mrbgems/mruby-compiler/core/y.tab.c"
 8983|      0|    break;
 8984|       |
 8985|      0|  case 381: /* block_param: f_block_optarg opt_block_args_tail  */
  ------------------
  |  Branch (8985:3): [True: 0, False: 12.5M]
  ------------------
 8986|      0|#line 3083 "mrbgems/mruby-compiler/core/parse.y"
 8987|      0|                    {
 8988|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
 8989|      0|                    }
 8990|      0|#line 8991 "mrbgems/mruby-compiler/core/y.tab.c"
 8991|      0|    break;
 8992|       |
 8993|      0|  case 382: /* block_param: f_block_optarg ',' f_arg opt_block_args_tail  */
  ------------------
  |  Branch (8993:3): [True: 0, False: 12.5M]
  ------------------
 8994|      0|#line 3087 "mrbgems/mruby-compiler/core/parse.y"
 8995|      0|                    {
 8996|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
 8997|      0|                    }
 8998|      0|#line 8999 "mrbgems/mruby-compiler/core/y.tab.c"
 8999|      0|    break;
 9000|       |
 9001|      0|  case 383: /* block_param: f_rest_arg opt_block_args_tail  */
  ------------------
  |  Branch (9001:3): [True: 0, False: 12.5M]
  ------------------
 9002|      0|#line 3091 "mrbgems/mruby-compiler/core/parse.y"
 9003|      0|                    {
 9004|      0|                      (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
 9005|      0|                    }
 9006|      0|#line 9007 "mrbgems/mruby-compiler/core/y.tab.c"
 9007|      0|    break;
 9008|       |
 9009|      0|  case 384: /* block_param: f_rest_arg ',' f_arg opt_block_args_tail  */
  ------------------
  |  Branch (9009:3): [True: 0, False: 12.5M]
  ------------------
 9010|      0|#line 3095 "mrbgems/mruby-compiler/core/parse.y"
 9011|      0|                    {
 9012|      0|                      (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
 9013|      0|                    }
 9014|      0|#line 9015 "mrbgems/mruby-compiler/core/y.tab.c"
 9015|      0|    break;
 9016|       |
 9017|      0|  case 385: /* block_param: block_args_tail  */
  ------------------
  |  Branch (9017:3): [True: 0, False: 12.5M]
  ------------------
 9018|      0|#line 3099 "mrbgems/mruby-compiler/core/parse.y"
 9019|      0|                    {
 9020|      0|                      (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
 9021|      0|                    }
 9022|      0|#line 9023 "mrbgems/mruby-compiler/core/y.tab.c"
 9023|      0|    break;
 9024|       |
 9025|      0|  case 386: /* opt_block_param: none  */
  ------------------
  |  Branch (9025:3): [True: 0, False: 12.5M]
  ------------------
 9026|      0|#line 3105 "mrbgems/mruby-compiler/core/parse.y"
 9027|      0|                    {
 9028|      0|                      local_add_blk(p, 0);
 9029|      0|                      (yyval.nd) = 0;
 9030|      0|                    }
 9031|      0|#line 9032 "mrbgems/mruby-compiler/core/y.tab.c"
 9032|      0|    break;
 9033|       |
 9034|      0|  case 387: /* opt_block_param: block_param_def  */
  ------------------
  |  Branch (9034:3): [True: 0, False: 12.5M]
  ------------------
 9035|      0|#line 3110 "mrbgems/mruby-compiler/core/parse.y"
 9036|      0|                   {
 9037|      0|                      p->cmd_start = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 9038|      0|                      (yyval.nd) = (yyvsp[0].nd);
 9039|      0|                    }
 9040|      0|#line 9041 "mrbgems/mruby-compiler/core/y.tab.c"
 9041|      0|    break;
 9042|       |
 9043|      0|  case 388: /* $@25: %empty  */
  ------------------
  |  Branch (9043:3): [True: 0, False: 12.5M]
  ------------------
 9044|      0|#line 3116 "mrbgems/mruby-compiler/core/parse.y"
 9045|      0|                      {local_add_blk(p, 0);}
 9046|      0|#line 9047 "mrbgems/mruby-compiler/core/y.tab.c"
 9047|      0|    break;
 9048|       |
 9049|      0|  case 389: /* block_param_def: '|' $@25 opt_bv_decl '|'  */
  ------------------
  |  Branch (9049:3): [True: 0, False: 12.5M]
  ------------------
 9050|      0|#line 3117 "mrbgems/mruby-compiler/core/parse.y"
 9051|      0|                    {
 9052|      0|                      (yyval.nd) = 0;
 9053|      0|                    }
 9054|      0|#line 9055 "mrbgems/mruby-compiler/core/y.tab.c"
 9055|      0|    break;
 9056|       |
 9057|      0|  case 390: /* block_param_def: "||"  */
  ------------------
  |  Branch (9057:3): [True: 0, False: 12.5M]
  ------------------
 9058|      0|#line 3121 "mrbgems/mruby-compiler/core/parse.y"
 9059|      0|                    {
 9060|      0|                      local_add_blk(p, 0);
 9061|      0|                      (yyval.nd) = 0;
 9062|      0|                    }
 9063|      0|#line 9064 "mrbgems/mruby-compiler/core/y.tab.c"
 9064|      0|    break;
 9065|       |
 9066|      0|  case 391: /* block_param_def: '|' block_param opt_bv_decl '|'  */
  ------------------
  |  Branch (9066:3): [True: 0, False: 12.5M]
  ------------------
 9067|      0|#line 3126 "mrbgems/mruby-compiler/core/parse.y"
 9068|      0|                    {
 9069|      0|                      (yyval.nd) = (yyvsp[-2].nd);
 9070|      0|                    }
 9071|      0|#line 9072 "mrbgems/mruby-compiler/core/y.tab.c"
 9072|      0|    break;
 9073|       |
 9074|      0|  case 392: /* opt_bv_decl: opt_nl  */
  ------------------
  |  Branch (9074:3): [True: 0, False: 12.5M]
  ------------------
 9075|      0|#line 3133 "mrbgems/mruby-compiler/core/parse.y"
 9076|      0|                    {
 9077|      0|                      (yyval.nd) = 0;
 9078|      0|                    }
 9079|      0|#line 9080 "mrbgems/mruby-compiler/core/y.tab.c"
 9080|      0|    break;
 9081|       |
 9082|      0|  case 393: /* opt_bv_decl: opt_nl ';' bv_decls opt_nl  */
  ------------------
  |  Branch (9082:3): [True: 0, False: 12.5M]
  ------------------
 9083|      0|#line 3137 "mrbgems/mruby-compiler/core/parse.y"
 9084|      0|                    {
 9085|      0|                      (yyval.nd) = 0;
 9086|      0|                    }
 9087|      0|#line 9088 "mrbgems/mruby-compiler/core/y.tab.c"
 9088|      0|    break;
 9089|       |
 9090|      0|  case 396: /* bvar: "local variable or method"  */
  ------------------
  |  Branch (9090:3): [True: 0, False: 12.5M]
  ------------------
 9091|      0|#line 3147 "mrbgems/mruby-compiler/core/parse.y"
 9092|      0|                    {
 9093|      0|                      local_add_f(p, (yyvsp[0].id));
 9094|      0|                      new_bv(p, (yyvsp[0].id));
 9095|      0|                    }
 9096|      0|#line 9097 "mrbgems/mruby-compiler/core/y.tab.c"
 9097|      0|    break;
 9098|       |
 9099|      0|  case 398: /* f_larglist: '(' f_args opt_bv_decl ')'  */
  ------------------
  |  Branch (9099:3): [True: 0, False: 12.5M]
  ------------------
 9100|      0|#line 3155 "mrbgems/mruby-compiler/core/parse.y"
 9101|      0|                    {
 9102|      0|                      (yyval.nd) = (yyvsp[-2].nd);
 9103|      0|                    }
 9104|      0|#line 9105 "mrbgems/mruby-compiler/core/y.tab.c"
 9105|      0|    break;
 9106|       |
 9107|      0|  case 399: /* f_larglist: f_args  */
  ------------------
  |  Branch (9107:3): [True: 0, False: 12.5M]
  ------------------
 9108|      0|#line 3159 "mrbgems/mruby-compiler/core/parse.y"
 9109|      0|                    {
 9110|      0|                      (yyval.nd) = (yyvsp[0].nd);
 9111|      0|                    }
 9112|      0|#line 9113 "mrbgems/mruby-compiler/core/y.tab.c"
 9113|      0|    break;
 9114|       |
 9115|      0|  case 400: /* lambda_body: tLAMBEG compstmt '}'  */
  ------------------
  |  Branch (9115:3): [True: 0, False: 12.5M]
  ------------------
 9116|      0|#line 3165 "mrbgems/mruby-compiler/core/parse.y"
 9117|      0|                    {
 9118|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 9119|      0|                    }
 9120|      0|#line 9121 "mrbgems/mruby-compiler/core/y.tab.c"
 9121|      0|    break;
 9122|       |
 9123|      0|  case 401: /* lambda_body: keyword_do_LAMBDA bodystmt keyword_end  */
  ------------------
  |  Branch (9123:3): [True: 0, False: 12.5M]
  ------------------
 9124|      0|#line 3169 "mrbgems/mruby-compiler/core/parse.y"
 9125|      0|                    {
 9126|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 9127|      0|                    }
 9128|      0|#line 9129 "mrbgems/mruby-compiler/core/y.tab.c"
 9129|      0|    break;
 9130|       |
 9131|      0|  case 402: /* @26: %empty  */
  ------------------
  |  Branch (9131:3): [True: 0, False: 12.5M]
  ------------------
 9132|      0|#line 3175 "mrbgems/mruby-compiler/core/parse.y"
 9133|      0|                    {
 9134|      0|                      local_nest(p);
 9135|      0|                      nvars_nest(p);
 9136|      0|                      (yyval.num) = p->lineno;
 9137|      0|                    }
 9138|      0|#line 9139 "mrbgems/mruby-compiler/core/y.tab.c"
 9139|      0|    break;
 9140|       |
 9141|      0|  case 403: /* do_block: keyword_do_block @26 opt_block_param bodystmt keyword_end  */
  ------------------
  |  Branch (9141:3): [True: 0, False: 12.5M]
  ------------------
 9142|      0|#line 3183 "mrbgems/mruby-compiler/core/parse.y"
 9143|      0|                    {
 9144|      0|                      (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
 9145|      0|                      SET_LINENO((yyval.nd), (yyvsp[-3].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 9146|      0|                      local_unnest(p);
 9147|      0|                      nvars_unnest(p);
 9148|      0|                    }
 9149|      0|#line 9150 "mrbgems/mruby-compiler/core/y.tab.c"
 9150|      0|    break;
 9151|       |
 9152|      0|  case 404: /* block_call: command do_block  */
  ------------------
  |  Branch (9152:3): [True: 0, False: 12.5M]
  ------------------
 9153|      0|#line 3192 "mrbgems/mruby-compiler/core/parse.y"
 9154|      0|                    {
 9155|      0|                      if (typen((yyvsp[-1].nd)->car) == NODE_YIELD) {
  ------------------
  |  |  136|      0|#define typen(x) ((enum node_type)(intptr_t)(x))
  ------------------
  |  Branch (9155:27): [True: 0, False: 0]
  ------------------
 9156|      0|                        yyerror(p, "block given to yield");
 9157|      0|                      }
 9158|      0|                      else {
 9159|      0|                        call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 9160|      0|                      }
 9161|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 9162|      0|                    }
 9163|      0|#line 9164 "mrbgems/mruby-compiler/core/y.tab.c"
 9164|      0|    break;
 9165|       |
 9166|      0|  case 405: /* block_call: block_call call_op2 operation2 opt_paren_args  */
  ------------------
  |  Branch (9166:3): [True: 0, False: 12.5M]
  ------------------
 9167|      0|#line 3202 "mrbgems/mruby-compiler/core/parse.y"
 9168|      0|                    {
 9169|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
 9170|      0|                    }
 9171|      0|#line 9172 "mrbgems/mruby-compiler/core/y.tab.c"
 9172|      0|    break;
 9173|       |
 9174|      0|  case 406: /* block_call: block_call call_op2 operation2 opt_paren_args brace_block  */
  ------------------
  |  Branch (9174:3): [True: 0, False: 12.5M]
  ------------------
 9175|      0|#line 3206 "mrbgems/mruby-compiler/core/parse.y"
 9176|      0|                    {
 9177|      0|                      (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
 9178|      0|                      call_with_block(p, (yyval.nd), (yyvsp[0].nd));
 9179|      0|                    }
 9180|      0|#line 9181 "mrbgems/mruby-compiler/core/y.tab.c"
 9181|      0|    break;
 9182|       |
 9183|      0|  case 407: /* block_call: block_call call_op2 operation2 command_args do_block  */
  ------------------
  |  Branch (9183:3): [True: 0, False: 12.5M]
  ------------------
 9184|      0|#line 3211 "mrbgems/mruby-compiler/core/parse.y"
 9185|      0|                    {
 9186|      0|                      (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
 9187|      0|                      call_with_block(p, (yyval.nd), (yyvsp[0].nd));
 9188|      0|                    }
 9189|      0|#line 9190 "mrbgems/mruby-compiler/core/y.tab.c"
 9190|      0|    break;
 9191|       |
 9192|      0|  case 408: /* method_call: operation paren_args  */
  ------------------
  |  Branch (9192:3): [True: 0, False: 12.5M]
  ------------------
 9193|      0|#line 3218 "mrbgems/mruby-compiler/core/parse.y"
 9194|      0|                    {
 9195|      0|                      (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
 9196|      0|                    }
 9197|      0|#line 9198 "mrbgems/mruby-compiler/core/y.tab.c"
 9198|      0|    break;
 9199|       |
 9200|  95.8k|  case 409: /* method_call: primary_value call_op operation2 opt_paren_args  */
  ------------------
  |  Branch (9200:3): [True: 95.8k, False: 12.4M]
  ------------------
 9201|  95.8k|#line 3222 "mrbgems/mruby-compiler/core/parse.y"
 9202|  95.8k|                    {
 9203|  95.8k|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
 9204|  95.8k|                    }
 9205|  95.8k|#line 9206 "mrbgems/mruby-compiler/core/y.tab.c"
 9206|  95.8k|    break;
 9207|       |
 9208|      0|  case 410: /* method_call: primary_value "::" operation2 paren_args  */
  ------------------
  |  Branch (9208:3): [True: 0, False: 12.5M]
  ------------------
 9209|      0|#line 3226 "mrbgems/mruby-compiler/core/parse.y"
 9210|      0|                    {
 9211|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
 9212|      0|                    }
 9213|      0|#line 9214 "mrbgems/mruby-compiler/core/y.tab.c"
 9214|      0|    break;
 9215|       |
 9216|      0|  case 411: /* method_call: primary_value "::" operation3  */
  ------------------
  |  Branch (9216:3): [True: 0, False: 12.5M]
  ------------------
 9217|      0|#line 3230 "mrbgems/mruby-compiler/core/parse.y"
 9218|      0|                    {
 9219|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
 9220|      0|                    }
 9221|      0|#line 9222 "mrbgems/mruby-compiler/core/y.tab.c"
 9222|      0|    break;
 9223|       |
 9224|      0|  case 412: /* method_call: primary_value call_op paren_args  */
  ------------------
  |  Branch (9224:3): [True: 0, False: 12.5M]
  ------------------
 9225|      0|#line 3234 "mrbgems/mruby-compiler/core/parse.y"
 9226|      0|                    {
 9227|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), (yyvsp[-1].num));
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 9228|      0|                    }
 9229|      0|#line 9230 "mrbgems/mruby-compiler/core/y.tab.c"
 9230|      0|    break;
 9231|       |
 9232|      0|  case 413: /* method_call: primary_value "::" paren_args  */
  ------------------
  |  Branch (9232:3): [True: 0, False: 12.5M]
  ------------------
 9233|      0|#line 3238 "mrbgems/mruby-compiler/core/parse.y"
 9234|      0|                    {
 9235|      0|                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), tCOLON2);
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 9236|      0|                    }
 9237|      0|#line 9238 "mrbgems/mruby-compiler/core/y.tab.c"
 9238|      0|    break;
 9239|       |
 9240|      0|  case 414: /* method_call: keyword_super paren_args  */
  ------------------
  |  Branch (9240:3): [True: 0, False: 12.5M]
  ------------------
 9241|      0|#line 3242 "mrbgems/mruby-compiler/core/parse.y"
 9242|      0|                    {
 9243|      0|                      (yyval.nd) = new_super(p, (yyvsp[0].nd));
 9244|      0|                    }
 9245|      0|#line 9246 "mrbgems/mruby-compiler/core/y.tab.c"
 9246|      0|    break;
 9247|       |
 9248|      0|  case 415: /* method_call: keyword_super  */
  ------------------
  |  Branch (9248:3): [True: 0, False: 12.5M]
  ------------------
 9249|      0|#line 3246 "mrbgems/mruby-compiler/core/parse.y"
 9250|      0|                    {
 9251|      0|                      (yyval.nd) = new_zsuper(p);
 9252|      0|                    }
 9253|      0|#line 9254 "mrbgems/mruby-compiler/core/y.tab.c"
 9254|      0|    break;
 9255|       |
 9256|      0|  case 416: /* method_call: primary_value '[' opt_call_args ']'  */
  ------------------
  |  Branch (9256:3): [True: 0, False: 12.5M]
  ------------------
 9257|      0|#line 3250 "mrbgems/mruby-compiler/core/parse.y"
 9258|      0|                    {
 9259|      0|                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.');
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
 9260|      0|                    }
 9261|      0|#line 9262 "mrbgems/mruby-compiler/core/y.tab.c"
 9262|      0|    break;
 9263|       |
 9264|      0|  case 417: /* @27: %empty  */
  ------------------
  |  Branch (9264:3): [True: 0, False: 12.5M]
  ------------------
 9265|      0|#line 3256 "mrbgems/mruby-compiler/core/parse.y"
 9266|      0|                    {
 9267|      0|                      local_nest(p);
 9268|      0|                      nvars_nest(p);
 9269|      0|                      (yyval.num) = p->lineno;
 9270|      0|                    }
 9271|      0|#line 9272 "mrbgems/mruby-compiler/core/y.tab.c"
 9272|      0|    break;
 9273|       |
 9274|      0|  case 418: /* brace_block: '{' @27 opt_block_param compstmt '}'  */
  ------------------
  |  Branch (9274:3): [True: 0, False: 12.5M]
  ------------------
 9275|      0|#line 3263 "mrbgems/mruby-compiler/core/parse.y"
 9276|      0|                    {
 9277|      0|                      (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
 9278|      0|                      SET_LINENO((yyval.nd), (yyvsp[-3].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 9279|      0|                      local_unnest(p);
 9280|      0|                      nvars_unnest(p);
 9281|      0|                    }
 9282|      0|#line 9283 "mrbgems/mruby-compiler/core/y.tab.c"
 9283|      0|    break;
 9284|       |
 9285|      0|  case 419: /* @28: %empty  */
  ------------------
  |  Branch (9285:3): [True: 0, False: 12.5M]
  ------------------
 9286|      0|#line 3270 "mrbgems/mruby-compiler/core/parse.y"
 9287|      0|                    {
 9288|      0|                      local_nest(p);
 9289|      0|                      nvars_nest(p);
 9290|      0|                      (yyval.num) = p->lineno;
 9291|      0|                    }
 9292|      0|#line 9293 "mrbgems/mruby-compiler/core/y.tab.c"
 9293|      0|    break;
 9294|       |
 9295|      0|  case 420: /* brace_block: keyword_do @28 opt_block_param bodystmt keyword_end  */
  ------------------
  |  Branch (9295:3): [True: 0, False: 12.5M]
  ------------------
 9296|      0|#line 3277 "mrbgems/mruby-compiler/core/parse.y"
 9297|      0|                    {
 9298|      0|                      (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
 9299|      0|                      SET_LINENO((yyval.nd), (yyvsp[-3].num));
  ------------------
  |  |  124|      0|#define SET_LINENO(c,n) ((c)->lineno = (n))
  ------------------
 9300|      0|                      local_unnest(p);
 9301|      0|                      nvars_unnest(p);
 9302|      0|                    }
 9303|      0|#line 9304 "mrbgems/mruby-compiler/core/y.tab.c"
 9304|      0|    break;
 9305|       |
 9306|      0|  case 421: /* case_body: keyword_when args then compstmt cases  */
  ------------------
  |  Branch (9306:3): [True: 0, False: 12.5M]
  ------------------
 9307|      0|#line 3288 "mrbgems/mruby-compiler/core/parse.y"
 9308|      0|                    {
 9309|      0|                      (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 9310|      0|                    }
 9311|      0|#line 9312 "mrbgems/mruby-compiler/core/y.tab.c"
 9312|      0|    break;
 9313|       |
 9314|      0|  case 422: /* cases: opt_else  */
  ------------------
  |  Branch (9314:3): [True: 0, False: 12.5M]
  ------------------
 9315|      0|#line 3294 "mrbgems/mruby-compiler/core/parse.y"
 9316|      0|                    {
 9317|      0|                      if ((yyvsp[0].nd)) {
  ------------------
  |  Branch (9317:27): [True: 0, False: 0]
  ------------------
 9318|      0|                        (yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0);
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 9319|      0|                      }
 9320|      0|                      else {
 9321|      0|                        (yyval.nd) = 0;
 9322|      0|                      }
 9323|      0|                    }
 9324|      0|#line 9325 "mrbgems/mruby-compiler/core/y.tab.c"
 9325|      0|    break;
 9326|       |
 9327|      0|  case 424: /* opt_rescue: keyword_rescue exc_list exc_var then compstmt opt_rescue  */
  ------------------
  |  Branch (9327:3): [True: 0, False: 12.5M]
  ------------------
 9328|      0|#line 3308 "mrbgems/mruby-compiler/core/parse.y"
 9329|      0|                    {
 9330|      0|                      (yyval.nd) = list1(list3((yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9331|      0|                      if ((yyvsp[0].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  267|      0|#define append(a,b) append_gen(p,(a),(b))
  ------------------
  |  Branch (9331:27): [True: 0, False: 0]
  ------------------
 9332|      0|                    }
 9333|      0|#line 9334 "mrbgems/mruby-compiler/core/y.tab.c"
 9334|      0|    break;
 9335|       |
 9336|      0|  case 426: /* exc_list: arg  */
  ------------------
  |  Branch (9336:3): [True: 0, False: 12.5M]
  ------------------
 9337|      0|#line 3316 "mrbgems/mruby-compiler/core/parse.y"
 9338|      0|                    {
 9339|      0|                        (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9340|      0|                    }
 9341|      0|#line 9342 "mrbgems/mruby-compiler/core/y.tab.c"
 9342|      0|    break;
 9343|       |
 9344|      0|  case 429: /* exc_var: "=>" lhs  */
  ------------------
  |  Branch (9344:3): [True: 0, False: 12.5M]
  ------------------
 9345|      0|#line 3324 "mrbgems/mruby-compiler/core/parse.y"
 9346|      0|                    {
 9347|      0|                      (yyval.nd) = (yyvsp[0].nd);
 9348|      0|                    }
 9349|      0|#line 9350 "mrbgems/mruby-compiler/core/y.tab.c"
 9350|      0|    break;
 9351|       |
 9352|      0|  case 431: /* opt_ensure: keyword_ensure compstmt  */
  ------------------
  |  Branch (9352:3): [True: 0, False: 12.5M]
  ------------------
 9353|      0|#line 3331 "mrbgems/mruby-compiler/core/parse.y"
 9354|      0|                    {
 9355|      0|                      (yyval.nd) = (yyvsp[0].nd);
 9356|      0|                    }
 9357|      0|#line 9358 "mrbgems/mruby-compiler/core/y.tab.c"
 9358|      0|    break;
 9359|       |
 9360|      0|  case 438: /* string: string string_fragment  */
  ------------------
  |  Branch (9360:3): [True: 0, False: 12.5M]
  ------------------
 9361|      0|#line 3345 "mrbgems/mruby-compiler/core/parse.y"
 9362|      0|                    {
 9363|      0|                      (yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 9364|      0|                    }
 9365|      0|#line 9366 "mrbgems/mruby-compiler/core/y.tab.c"
 9366|      0|    break;
 9367|       |
 9368|   258k|  case 441: /* string_fragment: "string literal" tSTRING  */
  ------------------
  |  Branch (9368:3): [True: 258k, False: 12.2M]
  ------------------
 9369|   258k|#line 3353 "mrbgems/mruby-compiler/core/parse.y"
 9370|   258k|                    {
 9371|   258k|                      (yyval.nd) = (yyvsp[0].nd);
 9372|   258k|                    }
 9373|   258k|#line 9374 "mrbgems/mruby-compiler/core/y.tab.c"
 9374|   258k|    break;
 9375|       |
 9376|      0|  case 442: /* string_fragment: "string literal" string_rep tSTRING  */
  ------------------
  |  Branch (9376:3): [True: 0, False: 12.5M]
  ------------------
 9377|      0|#line 3357 "mrbgems/mruby-compiler/core/parse.y"
 9378|      0|                    {
 9379|      0|                      node *n = (yyvsp[-1].nd);
 9380|      0|                      if (intn((yyvsp[0].nd)->cdr->cdr) > 0) {
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (9380:27): [True: 0, False: 0]
  ------------------
 9381|      0|                        n = push(n, (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9382|      0|                      }
 9383|      0|                      else {
 9384|      0|                        cons_free((yyvsp[0].nd));
  ------------------
  |  |  172|      0|#define cons_free(c) cons_free_gen(p, (c))
  ------------------
 9385|      0|                      }
 9386|      0|                      (yyval.nd) = new_dstr(p, n);
 9387|      0|                    }
 9388|      0|#line 9389 "mrbgems/mruby-compiler/core/y.tab.c"
 9389|      0|    break;
 9390|       |
 9391|      0|  case 444: /* string_rep: string_rep string_interp  */
  ------------------
  |  Branch (9391:3): [True: 0, False: 12.5M]
  ------------------
 9392|      0|#line 3371 "mrbgems/mruby-compiler/core/parse.y"
 9393|      0|                    {
 9394|      0|                      (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd));
  ------------------
  |  |  267|      0|#define append(a,b) append_gen(p,(a),(b))
  ------------------
 9395|      0|                    }
 9396|      0|#line 9397 "mrbgems/mruby-compiler/core/y.tab.c"
 9397|      0|    break;
 9398|       |
 9399|      0|  case 445: /* string_interp: tSTRING_MID  */
  ------------------
  |  Branch (9399:3): [True: 0, False: 12.5M]
  ------------------
 9400|      0|#line 3377 "mrbgems/mruby-compiler/core/parse.y"
 9401|      0|                    {
 9402|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9403|      0|                    }
 9404|      0|#line 9405 "mrbgems/mruby-compiler/core/y.tab.c"
 9405|      0|    break;
 9406|       |
 9407|      0|  case 446: /* @29: %empty  */
  ------------------
  |  Branch (9407:3): [True: 0, False: 12.5M]
  ------------------
 9408|      0|#line 3381 "mrbgems/mruby-compiler/core/parse.y"
 9409|      0|                    {
 9410|      0|                      (yyval.nd) = push_strterm(p);
 9411|      0|                    }
 9412|      0|#line 9413 "mrbgems/mruby-compiler/core/y.tab.c"
 9413|      0|    break;
 9414|       |
 9415|      0|  case 447: /* string_interp: tSTRING_PART @29 compstmt '}'  */
  ------------------
  |  Branch (9415:3): [True: 0, False: 12.5M]
  ------------------
 9416|      0|#line 3386 "mrbgems/mruby-compiler/core/parse.y"
 9417|      0|                    {
 9418|      0|                      pop_strterm(p,(yyvsp[-2].nd));
 9419|      0|                      (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd));
  ------------------
  |  |  224|      0|#define list2(a,b) list2_gen(p, (a),(b))
  ------------------
 9420|      0|                    }
 9421|      0|#line 9422 "mrbgems/mruby-compiler/core/y.tab.c"
 9422|      0|    break;
 9423|       |
 9424|      0|  case 448: /* string_interp: tLITERAL_DELIM  */
  ------------------
  |  Branch (9424:3): [True: 0, False: 12.5M]
  ------------------
 9425|      0|#line 3391 "mrbgems/mruby-compiler/core/parse.y"
 9426|      0|                    {
 9427|      0|                      (yyval.nd) = list1(new_literal_delim(p));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9428|      0|                    }
 9429|      0|#line 9430 "mrbgems/mruby-compiler/core/y.tab.c"
 9430|      0|    break;
 9431|       |
 9432|      0|  case 449: /* string_interp: tHD_LITERAL_DELIM heredoc_bodies  */
  ------------------
  |  Branch (9432:3): [True: 0, False: 12.5M]
  ------------------
 9433|      0|#line 3395 "mrbgems/mruby-compiler/core/parse.y"
 9434|      0|                    {
 9435|      0|                      (yyval.nd) = list1(new_literal_delim(p));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9436|      0|                    }
 9437|      0|#line 9438 "mrbgems/mruby-compiler/core/y.tab.c"
 9438|      0|    break;
 9439|       |
 9440|      0|  case 450: /* xstring: tXSTRING_BEG tXSTRING  */
  ------------------
  |  Branch (9440:3): [True: 0, False: 12.5M]
  ------------------
 9441|      0|#line 3401 "mrbgems/mruby-compiler/core/parse.y"
 9442|      0|                    {
 9443|      0|                        (yyval.nd) = (yyvsp[0].nd);
 9444|      0|                    }
 9445|      0|#line 9446 "mrbgems/mruby-compiler/core/y.tab.c"
 9446|      0|    break;
 9447|       |
 9448|      0|  case 451: /* xstring: tXSTRING_BEG string_rep tXSTRING  */
  ------------------
  |  Branch (9448:3): [True: 0, False: 12.5M]
  ------------------
 9449|      0|#line 3405 "mrbgems/mruby-compiler/core/parse.y"
 9450|      0|                    {
 9451|      0|                      node *n = (yyvsp[-1].nd);
 9452|      0|                      if (intn((yyvsp[0].nd)->cdr->cdr) > 0) {
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (9452:27): [True: 0, False: 0]
  ------------------
 9453|      0|                        n = push(n, (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9454|      0|                      }
 9455|      0|                      else {
 9456|      0|                        cons_free((yyvsp[0].nd));
  ------------------
  |  |  172|      0|#define cons_free(c) cons_free_gen(p, (c))
  ------------------
 9457|      0|                      }
 9458|      0|                      (yyval.nd) = new_dxstr(p, n);
 9459|      0|                    }
 9460|      0|#line 9461 "mrbgems/mruby-compiler/core/y.tab.c"
 9461|      0|    break;
 9462|       |
 9463|      0|  case 452: /* regexp: tREGEXP_BEG tREGEXP  */
  ------------------
  |  Branch (9463:3): [True: 0, False: 12.5M]
  ------------------
 9464|      0|#line 3418 "mrbgems/mruby-compiler/core/parse.y"
 9465|      0|                    {
 9466|      0|                        (yyval.nd) = (yyvsp[0].nd);
 9467|      0|                    }
 9468|      0|#line 9469 "mrbgems/mruby-compiler/core/y.tab.c"
 9469|      0|    break;
 9470|       |
 9471|      0|  case 453: /* regexp: tREGEXP_BEG string_rep tREGEXP  */
  ------------------
  |  Branch (9471:3): [True: 0, False: 12.5M]
  ------------------
 9472|      0|#line 3422 "mrbgems/mruby-compiler/core/parse.y"
 9473|      0|                    {
 9474|      0|                      (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd));
 9475|      0|                    }
 9476|      0|#line 9477 "mrbgems/mruby-compiler/core/y.tab.c"
 9477|      0|    break;
 9478|       |
 9479|      0|  case 457: /* heredoc_body: tHEREDOC_END  */
  ------------------
  |  Branch (9479:3): [True: 0, False: 12.5M]
  ------------------
 9480|      0|#line 3435 "mrbgems/mruby-compiler/core/parse.y"
 9481|      0|                    {
 9482|      0|                      parser_heredoc_info *info = parsing_heredoc_info(p);
 9483|      0|                      info->doc = push(info->doc, new_str(p, "", 0));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9484|      0|                      heredoc_end(p);
 9485|      0|                    }
 9486|      0|#line 9487 "mrbgems/mruby-compiler/core/y.tab.c"
 9487|      0|    break;
 9488|       |
 9489|      0|  case 458: /* heredoc_body: heredoc_string_rep tHEREDOC_END  */
  ------------------
  |  Branch (9489:3): [True: 0, False: 12.5M]
  ------------------
 9490|      0|#line 3441 "mrbgems/mruby-compiler/core/parse.y"
 9491|      0|                    {
 9492|      0|                      heredoc_end(p);
 9493|      0|                    }
 9494|      0|#line 9495 "mrbgems/mruby-compiler/core/y.tab.c"
 9495|      0|    break;
 9496|       |
 9497|      0|  case 461: /* heredoc_string_interp: tHD_STRING_MID  */
  ------------------
  |  Branch (9497:3): [True: 0, False: 12.5M]
  ------------------
 9498|      0|#line 3451 "mrbgems/mruby-compiler/core/parse.y"
 9499|      0|                    {
 9500|      0|                      parser_heredoc_info *info = parsing_heredoc_info(p);
 9501|      0|                      info->doc = push(info->doc, (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9502|      0|                      heredoc_treat_nextline(p);
 9503|      0|                    }
 9504|      0|#line 9505 "mrbgems/mruby-compiler/core/y.tab.c"
 9505|      0|    break;
 9506|       |
 9507|      0|  case 462: /* @30: %empty  */
  ------------------
  |  Branch (9507:3): [True: 0, False: 12.5M]
  ------------------
 9508|      0|#line 3457 "mrbgems/mruby-compiler/core/parse.y"
 9509|      0|                    {
 9510|      0|                      (yyval.nd) = push_strterm(p);
 9511|      0|                    }
 9512|      0|#line 9513 "mrbgems/mruby-compiler/core/y.tab.c"
 9513|      0|    break;
 9514|       |
 9515|      0|  case 463: /* heredoc_string_interp: tHD_STRING_PART @30 compstmt '}'  */
  ------------------
  |  Branch (9515:3): [True: 0, False: 12.5M]
  ------------------
 9516|      0|#line 3462 "mrbgems/mruby-compiler/core/parse.y"
 9517|      0|                    {
 9518|      0|                      pop_strterm(p, (yyvsp[-2].nd));
 9519|      0|                      parser_heredoc_info *info = parsing_heredoc_info(p);
 9520|      0|                      info->doc = push(push(info->doc, (yyvsp[-3].nd)), (yyvsp[-1].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9521|      0|                    }
 9522|      0|#line 9523 "mrbgems/mruby-compiler/core/y.tab.c"
 9523|      0|    break;
 9524|       |
 9525|      0|  case 464: /* words: tWORDS_BEG tSTRING  */
  ------------------
  |  Branch (9525:3): [True: 0, False: 12.5M]
  ------------------
 9526|      0|#line 3470 "mrbgems/mruby-compiler/core/parse.y"
 9527|      0|                    {
 9528|      0|                      (yyval.nd) = new_words(p, list1((yyvsp[0].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9529|      0|                    }
 9530|      0|#line 9531 "mrbgems/mruby-compiler/core/y.tab.c"
 9531|      0|    break;
 9532|       |
 9533|      0|  case 465: /* words: tWORDS_BEG string_rep tSTRING  */
  ------------------
  |  Branch (9533:3): [True: 0, False: 12.5M]
  ------------------
 9534|      0|#line 3474 "mrbgems/mruby-compiler/core/parse.y"
 9535|      0|                    {
 9536|      0|                      node *n = (yyvsp[-1].nd);
 9537|      0|                      if (intn((yyvsp[0].nd)->cdr->cdr) > 0) {
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (9537:27): [True: 0, False: 0]
  ------------------
 9538|      0|                        n = push(n, (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9539|      0|                      }
 9540|      0|                      else {
 9541|      0|                        cons_free((yyvsp[0].nd));
  ------------------
  |  |  172|      0|#define cons_free(c) cons_free_gen(p, (c))
  ------------------
 9542|      0|                      }
 9543|      0|                      (yyval.nd) = new_words(p, n);
 9544|      0|                    }
 9545|      0|#line 9546 "mrbgems/mruby-compiler/core/y.tab.c"
 9546|      0|    break;
 9547|       |
 9548|      0|  case 466: /* symbol: basic_symbol  */
  ------------------
  |  Branch (9548:3): [True: 0, False: 12.5M]
  ------------------
 9549|      0|#line 3488 "mrbgems/mruby-compiler/core/parse.y"
 9550|      0|                    {
 9551|      0|                      p->lstate = EXPR_ENDARG;
 9552|      0|                      (yyval.nd) = new_sym(p, (yyvsp[0].id));
 9553|      0|                    }
 9554|      0|#line 9555 "mrbgems/mruby-compiler/core/y.tab.c"
 9555|      0|    break;
 9556|       |
 9557|      0|  case 467: /* symbol: "symbol" "string literal" string_rep tSTRING  */
  ------------------
  |  Branch (9557:3): [True: 0, False: 12.5M]
  ------------------
 9558|      0|#line 3493 "mrbgems/mruby-compiler/core/parse.y"
 9559|      0|                    {
 9560|      0|                      node *n = (yyvsp[-1].nd);
 9561|      0|                      p->lstate = EXPR_ENDARG;
 9562|      0|                      if (intn((yyvsp[0].nd)->cdr->cdr) > 0) {
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (9562:27): [True: 0, False: 0]
  ------------------
 9563|      0|                        n = push(n, (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9564|      0|                      }
 9565|      0|                      else {
 9566|      0|                        cons_free((yyvsp[0].nd));
  ------------------
  |  |  172|      0|#define cons_free(c) cons_free_gen(p, (c))
  ------------------
 9567|      0|                      }
 9568|      0|                      (yyval.nd) = new_dsym(p, new_dstr(p, n));
 9569|      0|                    }
 9570|      0|#line 9571 "mrbgems/mruby-compiler/core/y.tab.c"
 9571|      0|    break;
 9572|       |
 9573|      0|  case 468: /* basic_symbol: "symbol" sym  */
  ------------------
  |  Branch (9573:3): [True: 0, False: 12.5M]
  ------------------
 9574|      0|#line 3507 "mrbgems/mruby-compiler/core/parse.y"
 9575|      0|                    {
 9576|      0|                      (yyval.id) = (yyvsp[0].id);
 9577|      0|                    }
 9578|      0|#line 9579 "mrbgems/mruby-compiler/core/y.tab.c"
 9579|      0|    break;
 9580|       |
 9581|      0|  case 473: /* sym: tSTRING  */
  ------------------
  |  Branch (9581:3): [True: 0, False: 12.5M]
  ------------------
 9582|      0|#line 3517 "mrbgems/mruby-compiler/core/parse.y"
 9583|      0|                    {
 9584|      0|                      (yyval.id) = new_strsym(p, (yyvsp[0].nd));
 9585|      0|                    }
 9586|      0|#line 9587 "mrbgems/mruby-compiler/core/y.tab.c"
 9587|      0|    break;
 9588|       |
 9589|      0|  case 474: /* sym: "string literal" tSTRING  */
  ------------------
  |  Branch (9589:3): [True: 0, False: 12.5M]
  ------------------
 9590|      0|#line 3521 "mrbgems/mruby-compiler/core/parse.y"
 9591|      0|                    {
 9592|      0|                      (yyval.id) = new_strsym(p, (yyvsp[0].nd));
 9593|      0|                    }
 9594|      0|#line 9595 "mrbgems/mruby-compiler/core/y.tab.c"
 9595|      0|    break;
 9596|       |
 9597|      0|  case 475: /* symbols: tSYMBOLS_BEG tSTRING  */
  ------------------
  |  Branch (9597:3): [True: 0, False: 12.5M]
  ------------------
 9598|      0|#line 3527 "mrbgems/mruby-compiler/core/parse.y"
 9599|      0|                    {
 9600|      0|                      (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd)));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9601|      0|                    }
 9602|      0|#line 9603 "mrbgems/mruby-compiler/core/y.tab.c"
 9603|      0|    break;
 9604|       |
 9605|      0|  case 476: /* symbols: tSYMBOLS_BEG string_rep tSTRING  */
  ------------------
  |  Branch (9605:3): [True: 0, False: 12.5M]
  ------------------
 9606|      0|#line 3531 "mrbgems/mruby-compiler/core/parse.y"
 9607|      0|                    {
 9608|      0|                      node *n = (yyvsp[-1].nd);
 9609|      0|                      if (intn((yyvsp[0].nd)->cdr->cdr) > 0) {
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (9609:27): [True: 0, False: 0]
  ------------------
 9610|      0|                        n = push(n, (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9611|      0|                      }
 9612|      0|                      (yyval.nd) = new_symbols(p, n);
 9613|      0|                    }
 9614|      0|#line 9615 "mrbgems/mruby-compiler/core/y.tab.c"
 9615|      0|    break;
 9616|       |
 9617|      0|  case 479: /* numeric: tUMINUS_NUM "integer literal"  */
  ------------------
  |  Branch (9617:3): [True: 0, False: 12.5M]
  ------------------
 9618|      0|#line 3543 "mrbgems/mruby-compiler/core/parse.y"
 9619|      0|                    {
 9620|      0|                      (yyval.nd) = new_negate(p, (yyvsp[0].nd));
 9621|      0|                    }
 9622|      0|#line 9623 "mrbgems/mruby-compiler/core/y.tab.c"
 9623|      0|    break;
 9624|       |
 9625|      0|  case 480: /* numeric: tUMINUS_NUM "float literal"  */
  ------------------
  |  Branch (9625:3): [True: 0, False: 12.5M]
  ------------------
 9626|      0|#line 3547 "mrbgems/mruby-compiler/core/parse.y"
 9627|      0|                    {
 9628|      0|                      (yyval.nd) = new_negate(p, (yyvsp[0].nd));
 9629|      0|                    }
 9630|      0|#line 9631 "mrbgems/mruby-compiler/core/y.tab.c"
 9631|      0|    break;
 9632|       |
 9633|   289k|  case 481: /* variable: "local variable or method"  */
  ------------------
  |  Branch (9633:3): [True: 289k, False: 12.2M]
  ------------------
 9634|   289k|#line 3553 "mrbgems/mruby-compiler/core/parse.y"
 9635|   289k|                    {
 9636|   289k|                      (yyval.nd) = new_lvar(p, (yyvsp[0].id));
 9637|   289k|                    }
 9638|   289k|#line 9639 "mrbgems/mruby-compiler/core/y.tab.c"
 9639|   289k|    break;
 9640|       |
 9641|  31.8k|  case 482: /* variable: "instance variable"  */
  ------------------
  |  Branch (9641:3): [True: 31.8k, False: 12.5M]
  ------------------
 9642|  31.8k|#line 3557 "mrbgems/mruby-compiler/core/parse.y"
 9643|  31.8k|                    {
 9644|  31.8k|                      (yyval.nd) = new_ivar(p, (yyvsp[0].id));
 9645|  31.8k|                    }
 9646|  31.8k|#line 9647 "mrbgems/mruby-compiler/core/y.tab.c"
 9647|  31.8k|    break;
 9648|       |
 9649|      0|  case 483: /* variable: "global variable"  */
  ------------------
  |  Branch (9649:3): [True: 0, False: 12.5M]
  ------------------
 9650|      0|#line 3561 "mrbgems/mruby-compiler/core/parse.y"
 9651|      0|                    {
 9652|      0|                      (yyval.nd) = new_gvar(p, (yyvsp[0].id));
 9653|      0|                    }
 9654|      0|#line 9655 "mrbgems/mruby-compiler/core/y.tab.c"
 9655|      0|    break;
 9656|       |
 9657|      0|  case 484: /* variable: "class variable"  */
  ------------------
  |  Branch (9657:3): [True: 0, False: 12.5M]
  ------------------
 9658|      0|#line 3565 "mrbgems/mruby-compiler/core/parse.y"
 9659|      0|                    {
 9660|      0|                      (yyval.nd) = new_cvar(p, (yyvsp[0].id));
 9661|      0|                    }
 9662|      0|#line 9663 "mrbgems/mruby-compiler/core/y.tab.c"
 9663|      0|    break;
 9664|       |
 9665|  43.1k|  case 485: /* variable: "constant"  */
  ------------------
  |  Branch (9665:3): [True: 43.1k, False: 12.5M]
  ------------------
 9666|  43.1k|#line 3569 "mrbgems/mruby-compiler/core/parse.y"
 9667|  43.1k|                    {
 9668|  43.1k|                      (yyval.nd) = new_const(p, (yyvsp[0].id));
 9669|  43.1k|                    }
 9670|  43.1k|#line 9671 "mrbgems/mruby-compiler/core/y.tab.c"
 9671|  43.1k|    break;
 9672|       |
 9673|  31.8k|  case 486: /* var_lhs: variable  */
  ------------------
  |  Branch (9673:3): [True: 31.8k, False: 12.5M]
  ------------------
 9674|  31.8k|#line 3575 "mrbgems/mruby-compiler/core/parse.y"
 9675|  31.8k|                    {
 9676|  31.8k|                      assignable(p, (yyvsp[0].nd));
 9677|  31.8k|                    }
 9678|  31.8k|#line 9679 "mrbgems/mruby-compiler/core/y.tab.c"
 9679|  31.8k|    break;
 9680|       |
 9681|      0|  case 487: /* var_lhs: "numbered parameter"  */
  ------------------
  |  Branch (9681:3): [True: 0, False: 12.5M]
  ------------------
 9682|      0|#line 3579 "mrbgems/mruby-compiler/core/parse.y"
 9683|      0|                    {
 9684|      0|                      yyerror(p, "can't assign to numbered parameter");
 9685|      0|                    }
 9686|      0|#line 9687 "mrbgems/mruby-compiler/core/y.tab.c"
 9687|      0|    break;
 9688|       |
 9689|   117k|  case 488: /* var_ref: variable  */
  ------------------
  |  Branch (9689:3): [True: 117k, False: 12.4M]
  ------------------
 9690|   117k|#line 3585 "mrbgems/mruby-compiler/core/parse.y"
 9691|   117k|                    {
 9692|   117k|                      (yyval.nd) = var_reference(p, (yyvsp[0].nd));
 9693|   117k|                    }
 9694|   117k|#line 9695 "mrbgems/mruby-compiler/core/y.tab.c"
 9695|   117k|    break;
 9696|       |
 9697|      0|  case 489: /* var_ref: keyword_nil  */
  ------------------
  |  Branch (9697:3): [True: 0, False: 12.5M]
  ------------------
 9698|      0|#line 3589 "mrbgems/mruby-compiler/core/parse.y"
 9699|      0|                    {
 9700|      0|                      (yyval.nd) = new_nil(p);
 9701|      0|                    }
 9702|      0|#line 9703 "mrbgems/mruby-compiler/core/y.tab.c"
 9703|      0|    break;
 9704|       |
 9705|      0|  case 490: /* var_ref: keyword_self  */
  ------------------
  |  Branch (9705:3): [True: 0, False: 12.5M]
  ------------------
 9706|      0|#line 3593 "mrbgems/mruby-compiler/core/parse.y"
 9707|      0|                    {
 9708|      0|                      (yyval.nd) = new_self(p);
 9709|      0|                    }
 9710|      0|#line 9711 "mrbgems/mruby-compiler/core/y.tab.c"
 9711|      0|    break;
 9712|       |
 9713|      0|  case 491: /* var_ref: keyword_true  */
  ------------------
  |  Branch (9713:3): [True: 0, False: 12.5M]
  ------------------
 9714|      0|#line 3597 "mrbgems/mruby-compiler/core/parse.y"
 9715|      0|                    {
 9716|      0|                      (yyval.nd) = new_true(p);
 9717|      0|                    }
 9718|      0|#line 9719 "mrbgems/mruby-compiler/core/y.tab.c"
 9719|      0|    break;
 9720|       |
 9721|      0|  case 492: /* var_ref: keyword_false  */
  ------------------
  |  Branch (9721:3): [True: 0, False: 12.5M]
  ------------------
 9722|      0|#line 3601 "mrbgems/mruby-compiler/core/parse.y"
 9723|      0|                    {
 9724|      0|                      (yyval.nd) = new_false(p);
 9725|      0|                    }
 9726|      0|#line 9727 "mrbgems/mruby-compiler/core/y.tab.c"
 9727|      0|    break;
 9728|       |
 9729|      0|  case 493: /* var_ref: keyword__FILE__  */
  ------------------
  |  Branch (9729:3): [True: 0, False: 12.5M]
  ------------------
 9730|      0|#line 3605 "mrbgems/mruby-compiler/core/parse.y"
 9731|      0|                    {
 9732|      0|                      const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
 9733|      0|                      if (!fn) {
  ------------------
  |  Branch (9733:27): [True: 0, False: 0]
  ------------------
 9734|      0|                        fn = "(null)";
 9735|      0|                      }
 9736|      0|                      (yyval.nd) = new_str(p, fn, strlen(fn));
 9737|      0|                    }
 9738|      0|#line 9739 "mrbgems/mruby-compiler/core/y.tab.c"
 9739|      0|    break;
 9740|       |
 9741|      0|  case 494: /* var_ref: keyword__LINE__  */
  ------------------
  |  Branch (9741:3): [True: 0, False: 12.5M]
  ------------------
 9742|      0|#line 3613 "mrbgems/mruby-compiler/core/parse.y"
 9743|      0|                    {
 9744|      0|                      char buf[16];
 9745|       |
 9746|      0|                      dump_int(p->lineno, buf);
 9747|      0|                      (yyval.nd) = new_int(p, buf, 10, 0);
 9748|      0|                    }
 9749|      0|#line 9750 "mrbgems/mruby-compiler/core/y.tab.c"
 9750|      0|    break;
 9751|       |
 9752|      0|  case 495: /* var_ref: keyword__ENCODING__  */
  ------------------
  |  Branch (9752:3): [True: 0, False: 12.5M]
  ------------------
 9753|      0|#line 3620 "mrbgems/mruby-compiler/core/parse.y"
 9754|      0|                    {
 9755|      0|                      (yyval.nd) = new_fcall(p, MRB_SYM_2(p->mrb, __ENCODING__), 0);
  ------------------
  |  |   26|      0|#define MRB_SYM_2(mrb, name) MRB_SYM__##name
  ------------------
 9756|      0|                    }
 9757|      0|#line 9758 "mrbgems/mruby-compiler/core/y.tab.c"
 9758|      0|    break;
 9759|       |
 9760|      0|  case 498: /* superclass: %empty  */
  ------------------
  |  Branch (9760:3): [True: 0, False: 12.5M]
  ------------------
 9761|      0|#line 3630 "mrbgems/mruby-compiler/core/parse.y"
 9762|      0|                    {
 9763|      0|                      (yyval.nd) = 0;
 9764|      0|                    }
 9765|      0|#line 9766 "mrbgems/mruby-compiler/core/y.tab.c"
 9766|      0|    break;
 9767|       |
 9768|      0|  case 499: /* $@31: %empty  */
  ------------------
  |  Branch (9768:3): [True: 0, False: 12.5M]
  ------------------
 9769|      0|#line 3634 "mrbgems/mruby-compiler/core/parse.y"
 9770|      0|                    {
 9771|      0|                      p->lstate = EXPR_BEG;
 9772|      0|                      p->cmd_start = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 9773|      0|                    }
 9774|      0|#line 9775 "mrbgems/mruby-compiler/core/y.tab.c"
 9775|      0|    break;
 9776|       |
 9777|      0|  case 500: /* superclass: '<' $@31 expr_value term  */
  ------------------
  |  Branch (9777:3): [True: 0, False: 12.5M]
  ------------------
 9778|      0|#line 3639 "mrbgems/mruby-compiler/core/parse.y"
 9779|      0|                    {
 9780|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 9781|      0|                    }
 9782|      0|#line 9783 "mrbgems/mruby-compiler/core/y.tab.c"
 9783|      0|    break;
 9784|       |
 9785|  1.74k|  case 503: /* f_arglist_paren: '(' f_args rparen  */
  ------------------
  |  Branch (9785:3): [True: 1.74k, False: 12.5M]
  ------------------
 9786|  1.74k|#line 3655 "mrbgems/mruby-compiler/core/parse.y"
 9787|  1.74k|                    {
 9788|  1.74k|                      (yyval.nd) = (yyvsp[-1].nd);
 9789|  1.74k|                      p->lstate = EXPR_BEG;
 9790|  1.74k|                      p->cmd_start = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
 9791|  1.74k|                    }
 9792|  1.74k|#line 9793 "mrbgems/mruby-compiler/core/y.tab.c"
 9793|  1.74k|    break;
 9794|       |
 9795|      0|  case 504: /* f_arglist_paren: '(' f_arg ',' tBDOT3 rparen  */
  ------------------
  |  Branch (9795:3): [True: 0, False: 12.5M]
  ------------------
 9796|      0|#line 3661 "mrbgems/mruby-compiler/core/parse.y"
 9797|      0|                    {
 9798|      0|                      (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd));
 9799|      0|                    }
 9800|      0|#line 9801 "mrbgems/mruby-compiler/core/y.tab.c"
 9801|      0|    break;
 9802|       |
 9803|      0|  case 505: /* f_arglist_paren: '(' tBDOT3 rparen  */
  ------------------
  |  Branch (9803:3): [True: 0, False: 12.5M]
  ------------------
 9804|      0|#line 3665 "mrbgems/mruby-compiler/core/parse.y"
 9805|      0|                    {
 9806|      0|                      (yyval.nd) = new_args_dots(p, 0);
 9807|      0|                    }
 9808|      0|#line 9809 "mrbgems/mruby-compiler/core/y.tab.c"
 9809|      0|    break;
 9810|       |
 9811|      0|  case 507: /* f_arglist: f_args term  */
  ------------------
  |  Branch (9811:3): [True: 0, False: 12.5M]
  ------------------
 9812|      0|#line 3672 "mrbgems/mruby-compiler/core/parse.y"
 9813|      0|                    {
 9814|      0|                      (yyval.nd) = (yyvsp[-1].nd);
 9815|      0|                    }
 9816|      0|#line 9817 "mrbgems/mruby-compiler/core/y.tab.c"
 9817|      0|    break;
 9818|       |
 9819|      0|  case 508: /* f_arglist: f_arg ',' tBDOT3 term  */
  ------------------
  |  Branch (9819:3): [True: 0, False: 12.5M]
  ------------------
 9820|      0|#line 3676 "mrbgems/mruby-compiler/core/parse.y"
 9821|      0|                    {
 9822|      0|                      (yyval.nd) = new_args_dots(p, (yyvsp[-3].nd));
 9823|      0|                    }
 9824|      0|#line 9825 "mrbgems/mruby-compiler/core/y.tab.c"
 9825|      0|    break;
 9826|       |
 9827|      0|  case 509: /* f_arglist: "..." term  */
  ------------------
  |  Branch (9827:3): [True: 0, False: 12.5M]
  ------------------
 9828|      0|#line 3680 "mrbgems/mruby-compiler/core/parse.y"
 9829|      0|                    {
 9830|      0|                      (yyval.nd) = new_args_dots(p, 0);
 9831|      0|                    }
 9832|      0|#line 9833 "mrbgems/mruby-compiler/core/y.tab.c"
 9833|      0|    break;
 9834|       |
 9835|      0|  case 510: /* f_label: "local variable or method" "label"  */
  ------------------
  |  Branch (9835:3): [True: 0, False: 12.5M]
  ------------------
 9836|      0|#line 3686 "mrbgems/mruby-compiler/core/parse.y"
 9837|      0|                    {
 9838|      0|                      local_nest(p);
 9839|      0|                    }
 9840|      0|#line 9841 "mrbgems/mruby-compiler/core/y.tab.c"
 9841|      0|    break;
 9842|       |
 9843|      0|  case 511: /* f_label: "numbered parameter" "label"  */
  ------------------
  |  Branch (9843:3): [True: 0, False: 12.5M]
  ------------------
 9844|      0|#line 3690 "mrbgems/mruby-compiler/core/parse.y"
 9845|      0|                    {
 9846|      0|                      local_nest(p);
 9847|      0|                    }
 9848|      0|#line 9849 "mrbgems/mruby-compiler/core/y.tab.c"
 9849|      0|    break;
 9850|       |
 9851|      0|  case 512: /* f_kw: f_label arg  */
  ------------------
  |  Branch (9851:3): [True: 0, False: 12.5M]
  ------------------
 9852|      0|#line 3696 "mrbgems/mruby-compiler/core/parse.y"
 9853|      0|                    {
 9854|      0|                      void_expr_error(p, (yyvsp[0].nd));
 9855|      0|                      (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 9856|      0|                      local_unnest(p);
 9857|      0|                    }
 9858|      0|#line 9859 "mrbgems/mruby-compiler/core/y.tab.c"
 9859|      0|    break;
 9860|       |
 9861|      0|  case 513: /* f_kw: f_label  */
  ------------------
  |  Branch (9861:3): [True: 0, False: 12.5M]
  ------------------
 9862|      0|#line 3702 "mrbgems/mruby-compiler/core/parse.y"
 9863|      0|                    {
 9864|      0|                      (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
 9865|      0|                      local_unnest(p);
 9866|      0|                    }
 9867|      0|#line 9868 "mrbgems/mruby-compiler/core/y.tab.c"
 9868|      0|    break;
 9869|       |
 9870|      0|  case 514: /* f_block_kw: f_label primary_value  */
  ------------------
  |  Branch (9870:3): [True: 0, False: 12.5M]
  ------------------
 9871|      0|#line 3709 "mrbgems/mruby-compiler/core/parse.y"
 9872|      0|                    {
 9873|      0|                      void_expr_error(p, (yyvsp[0].nd));
 9874|      0|                      (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 9875|      0|                      local_unnest(p);
 9876|      0|                    }
 9877|      0|#line 9878 "mrbgems/mruby-compiler/core/y.tab.c"
 9878|      0|    break;
 9879|       |
 9880|      0|  case 515: /* f_block_kw: f_label  */
  ------------------
  |  Branch (9880:3): [True: 0, False: 12.5M]
  ------------------
 9881|      0|#line 3715 "mrbgems/mruby-compiler/core/parse.y"
 9882|      0|                    {
 9883|      0|                      (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
 9884|      0|                      local_unnest(p);
 9885|      0|                    }
 9886|      0|#line 9887 "mrbgems/mruby-compiler/core/y.tab.c"
 9887|      0|    break;
 9888|       |
 9889|      0|  case 516: /* f_block_kwarg: f_block_kw  */
  ------------------
  |  Branch (9889:3): [True: 0, False: 12.5M]
  ------------------
 9890|      0|#line 3722 "mrbgems/mruby-compiler/core/parse.y"
 9891|      0|                    {
 9892|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9893|      0|                    }
 9894|      0|#line 9895 "mrbgems/mruby-compiler/core/y.tab.c"
 9895|      0|    break;
 9896|       |
 9897|      0|  case 517: /* f_block_kwarg: f_block_kwarg ',' f_block_kw  */
  ------------------
  |  Branch (9897:3): [True: 0, False: 12.5M]
  ------------------
 9898|      0|#line 3726 "mrbgems/mruby-compiler/core/parse.y"
 9899|      0|                    {
 9900|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9901|      0|                    }
 9902|      0|#line 9903 "mrbgems/mruby-compiler/core/y.tab.c"
 9903|      0|    break;
 9904|       |
 9905|      0|  case 518: /* f_kwarg: f_kw  */
  ------------------
  |  Branch (9905:3): [True: 0, False: 12.5M]
  ------------------
 9906|      0|#line 3732 "mrbgems/mruby-compiler/core/parse.y"
 9907|      0|                    {
 9908|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
 9909|      0|                    }
 9910|      0|#line 9911 "mrbgems/mruby-compiler/core/y.tab.c"
 9911|      0|    break;
 9912|       |
 9913|      0|  case 519: /* f_kwarg: f_kwarg ',' f_kw  */
  ------------------
  |  Branch (9913:3): [True: 0, False: 12.5M]
  ------------------
 9914|      0|#line 3736 "mrbgems/mruby-compiler/core/parse.y"
 9915|      0|                    {
 9916|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
 9917|      0|                    }
 9918|      0|#line 9919 "mrbgems/mruby-compiler/core/y.tab.c"
 9919|      0|    break;
 9920|       |
 9921|      0|  case 522: /* f_kwrest: kwrest_mark "local variable or method"  */
  ------------------
  |  Branch (9921:3): [True: 0, False: 12.5M]
  ------------------
 9922|      0|#line 3746 "mrbgems/mruby-compiler/core/parse.y"
 9923|      0|                    {
 9924|      0|                      (yyval.nd) = new_kw_rest_args(p, (yyvsp[0].id));
 9925|      0|                    }
 9926|      0|#line 9927 "mrbgems/mruby-compiler/core/y.tab.c"
 9927|      0|    break;
 9928|       |
 9929|      0|  case 523: /* f_kwrest: kwrest_mark  */
  ------------------
  |  Branch (9929:3): [True: 0, False: 12.5M]
  ------------------
 9930|      0|#line 3750 "mrbgems/mruby-compiler/core/parse.y"
 9931|      0|                    {
 9932|      0|                      (yyval.nd) = new_kw_rest_args(p, 0);
 9933|      0|                    }
 9934|      0|#line 9935 "mrbgems/mruby-compiler/core/y.tab.c"
 9935|      0|    break;
 9936|       |
 9937|      0|  case 524: /* args_tail: f_kwarg ',' f_kwrest opt_f_block_arg  */
  ------------------
  |  Branch (9937:3): [True: 0, False: 12.5M]
  ------------------
 9938|      0|#line 3756 "mrbgems/mruby-compiler/core/parse.y"
 9939|      0|                    {
 9940|      0|                      (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
 9941|      0|                    }
 9942|      0|#line 9943 "mrbgems/mruby-compiler/core/y.tab.c"
 9943|      0|    break;
 9944|       |
 9945|      0|  case 525: /* args_tail: f_kwarg opt_f_block_arg  */
  ------------------
  |  Branch (9945:3): [True: 0, False: 12.5M]
  ------------------
 9946|      0|#line 3760 "mrbgems/mruby-compiler/core/parse.y"
 9947|      0|                    {
 9948|      0|                      (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
 9949|      0|                    }
 9950|      0|#line 9951 "mrbgems/mruby-compiler/core/y.tab.c"
 9951|      0|    break;
 9952|       |
 9953|      0|  case 526: /* args_tail: f_kwrest opt_f_block_arg  */
  ------------------
  |  Branch (9953:3): [True: 0, False: 12.5M]
  ------------------
 9954|      0|#line 3764 "mrbgems/mruby-compiler/core/parse.y"
 9955|      0|                    {
 9956|      0|                      (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
 9957|      0|                    }
 9958|      0|#line 9959 "mrbgems/mruby-compiler/core/y.tab.c"
 9959|      0|    break;
 9960|       |
 9961|      0|  case 527: /* args_tail: f_block_arg  */
  ------------------
  |  Branch (9961:3): [True: 0, False: 12.5M]
  ------------------
 9962|      0|#line 3768 "mrbgems/mruby-compiler/core/parse.y"
 9963|      0|                    {
 9964|      0|                      (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
 9965|      0|                    }
 9966|      0|#line 9967 "mrbgems/mruby-compiler/core/y.tab.c"
 9967|      0|    break;
 9968|       |
 9969|      0|  case 528: /* opt_args_tail: ',' args_tail  */
  ------------------
  |  Branch (9969:3): [True: 0, False: 12.5M]
  ------------------
 9970|      0|#line 3774 "mrbgems/mruby-compiler/core/parse.y"
 9971|      0|                    {
 9972|      0|                      (yyval.nd) = (yyvsp[0].nd);
 9973|      0|                    }
 9974|      0|#line 9975 "mrbgems/mruby-compiler/core/y.tab.c"
 9975|      0|    break;
 9976|       |
 9977|      0|  case 529: /* opt_args_tail: %empty  */
  ------------------
  |  Branch (9977:3): [True: 0, False: 12.5M]
  ------------------
 9978|      0|#line 3778 "mrbgems/mruby-compiler/core/parse.y"
 9979|      0|                    {
 9980|      0|                      (yyval.nd) = new_args_tail(p, 0, 0, 0);
 9981|      0|                    }
 9982|      0|#line 9983 "mrbgems/mruby-compiler/core/y.tab.c"
 9983|      0|    break;
 9984|       |
 9985|      0|  case 530: /* f_args: f_arg ',' f_optarg ',' f_rest_arg opt_args_tail  */
  ------------------
  |  Branch (9985:3): [True: 0, False: 12.5M]
  ------------------
 9986|      0|#line 3784 "mrbgems/mruby-compiler/core/parse.y"
 9987|      0|                    {
 9988|      0|                      (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
 9989|      0|                    }
 9990|      0|#line 9991 "mrbgems/mruby-compiler/core/y.tab.c"
 9991|      0|    break;
 9992|       |
 9993|      0|  case 531: /* f_args: f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_args_tail  */
  ------------------
  |  Branch (9993:3): [True: 0, False: 12.5M]
  ------------------
 9994|      0|#line 3788 "mrbgems/mruby-compiler/core/parse.y"
 9995|      0|                    {
 9996|      0|                      (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
 9997|      0|                    }
 9998|      0|#line 9999 "mrbgems/mruby-compiler/core/y.tab.c"
 9999|      0|    break;
10000|       |
10001|      0|  case 532: /* f_args: f_arg ',' f_optarg opt_args_tail  */
  ------------------
  |  Branch (10001:3): [True: 0, False: 12.5M]
  ------------------
10002|      0|#line 3792 "mrbgems/mruby-compiler/core/parse.y"
10003|      0|                    {
10004|      0|                      (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
10005|      0|                    }
10006|      0|#line 10007 "mrbgems/mruby-compiler/core/y.tab.c"
10007|      0|    break;
10008|       |
10009|      0|  case 533: /* f_args: f_arg ',' f_optarg ',' f_arg opt_args_tail  */
  ------------------
  |  Branch (10009:3): [True: 0, False: 12.5M]
  ------------------
10010|      0|#line 3796 "mrbgems/mruby-compiler/core/parse.y"
10011|      0|                    {
10012|      0|                      (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
10013|      0|                    }
10014|      0|#line 10015 "mrbgems/mruby-compiler/core/y.tab.c"
10015|      0|    break;
10016|       |
10017|      0|  case 534: /* f_args: f_arg ',' f_rest_arg opt_args_tail  */
  ------------------
  |  Branch (10017:3): [True: 0, False: 12.5M]
  ------------------
10018|      0|#line 3800 "mrbgems/mruby-compiler/core/parse.y"
10019|      0|                    {
10020|      0|                      (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
10021|      0|                    }
10022|      0|#line 10023 "mrbgems/mruby-compiler/core/y.tab.c"
10023|      0|    break;
10024|       |
10025|      0|  case 535: /* f_args: f_arg ',' f_rest_arg ',' f_arg opt_args_tail  */
  ------------------
  |  Branch (10025:3): [True: 0, False: 12.5M]
  ------------------
10026|      0|#line 3804 "mrbgems/mruby-compiler/core/parse.y"
10027|      0|                    {
10028|      0|                      (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
10029|      0|                    }
10030|      0|#line 10031 "mrbgems/mruby-compiler/core/y.tab.c"
10031|      0|    break;
10032|       |
10033|      0|  case 536: /* f_args: f_arg opt_args_tail  */
  ------------------
  |  Branch (10033:3): [True: 0, False: 12.5M]
  ------------------
10034|      0|#line 3808 "mrbgems/mruby-compiler/core/parse.y"
10035|      0|                    {
10036|      0|                      (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
10037|      0|                    }
10038|      0|#line 10039 "mrbgems/mruby-compiler/core/y.tab.c"
10039|      0|    break;
10040|       |
10041|      0|  case 537: /* f_args: f_optarg ',' f_rest_arg opt_args_tail  */
  ------------------
  |  Branch (10041:3): [True: 0, False: 12.5M]
  ------------------
10042|      0|#line 3812 "mrbgems/mruby-compiler/core/parse.y"
10043|      0|                    {
10044|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
10045|      0|                    }
10046|      0|#line 10047 "mrbgems/mruby-compiler/core/y.tab.c"
10047|      0|    break;
10048|       |
10049|      0|  case 538: /* f_args: f_optarg ',' f_rest_arg ',' f_arg opt_args_tail  */
  ------------------
  |  Branch (10049:3): [True: 0, False: 12.5M]
  ------------------
10050|      0|#line 3816 "mrbgems/mruby-compiler/core/parse.y"
10051|      0|                    {
10052|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
10053|      0|                    }
10054|      0|#line 10055 "mrbgems/mruby-compiler/core/y.tab.c"
10055|      0|    break;
10056|       |
10057|      0|  case 539: /* f_args: f_optarg opt_args_tail  */
  ------------------
  |  Branch (10057:3): [True: 0, False: 12.5M]
  ------------------
10058|      0|#line 3820 "mrbgems/mruby-compiler/core/parse.y"
10059|      0|                    {
10060|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
10061|      0|                    }
10062|      0|#line 10063 "mrbgems/mruby-compiler/core/y.tab.c"
10063|      0|    break;
10064|       |
10065|      0|  case 540: /* f_args: f_optarg ',' f_arg opt_args_tail  */
  ------------------
  |  Branch (10065:3): [True: 0, False: 12.5M]
  ------------------
10066|      0|#line 3824 "mrbgems/mruby-compiler/core/parse.y"
10067|      0|                    {
10068|      0|                      (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
10069|      0|                    }
10070|      0|#line 10071 "mrbgems/mruby-compiler/core/y.tab.c"
10071|      0|    break;
10072|       |
10073|      0|  case 541: /* f_args: f_rest_arg opt_args_tail  */
  ------------------
  |  Branch (10073:3): [True: 0, False: 12.5M]
  ------------------
10074|      0|#line 3828 "mrbgems/mruby-compiler/core/parse.y"
10075|      0|                    {
10076|      0|                      (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
10077|      0|                    }
10078|      0|#line 10079 "mrbgems/mruby-compiler/core/y.tab.c"
10079|      0|    break;
10080|       |
10081|      0|  case 542: /* f_args: f_rest_arg ',' f_arg opt_args_tail  */
  ------------------
  |  Branch (10081:3): [True: 0, False: 12.5M]
  ------------------
10082|      0|#line 3832 "mrbgems/mruby-compiler/core/parse.y"
10083|      0|                    {
10084|      0|                      (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
10085|      0|                    }
10086|      0|#line 10087 "mrbgems/mruby-compiler/core/y.tab.c"
10087|      0|    break;
10088|       |
10089|      0|  case 543: /* f_args: args_tail  */
  ------------------
  |  Branch (10089:3): [True: 0, False: 12.5M]
  ------------------
10090|      0|#line 3836 "mrbgems/mruby-compiler/core/parse.y"
10091|      0|                    {
10092|      0|                      (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
10093|      0|                    }
10094|      0|#line 10095 "mrbgems/mruby-compiler/core/y.tab.c"
10095|      0|    break;
10096|       |
10097|  1.74k|  case 544: /* f_args: %empty  */
  ------------------
  |  Branch (10097:3): [True: 1.74k, False: 12.5M]
  ------------------
10098|  1.74k|#line 3840 "mrbgems/mruby-compiler/core/parse.y"
10099|  1.74k|                    {
10100|  1.74k|                      local_add_f(p, 0);
10101|  1.74k|                      (yyval.nd) = new_args(p, 0, 0, 0, 0, 0);
10102|  1.74k|                    }
10103|  1.74k|#line 10104 "mrbgems/mruby-compiler/core/y.tab.c"
10104|  1.74k|    break;
10105|       |
10106|      0|  case 545: /* f_bad_arg: "constant"  */
  ------------------
  |  Branch (10106:3): [True: 0, False: 12.5M]
  ------------------
10107|      0|#line 3847 "mrbgems/mruby-compiler/core/parse.y"
10108|      0|                    {
10109|      0|                      yyerror(p, "formal argument cannot be a constant");
10110|      0|                      (yyval.nd) = 0;
10111|      0|                    }
10112|      0|#line 10113 "mrbgems/mruby-compiler/core/y.tab.c"
10113|      0|    break;
10114|       |
10115|      0|  case 546: /* f_bad_arg: "instance variable"  */
  ------------------
  |  Branch (10115:3): [True: 0, False: 12.5M]
  ------------------
10116|      0|#line 3852 "mrbgems/mruby-compiler/core/parse.y"
10117|      0|                    {
10118|      0|                      yyerror(p, "formal argument cannot be an instance variable");
10119|      0|                      (yyval.nd) = 0;
10120|      0|                    }
10121|      0|#line 10122 "mrbgems/mruby-compiler/core/y.tab.c"
10122|      0|    break;
10123|       |
10124|      0|  case 547: /* f_bad_arg: "global variable"  */
  ------------------
  |  Branch (10124:3): [True: 0, False: 12.5M]
  ------------------
10125|      0|#line 3857 "mrbgems/mruby-compiler/core/parse.y"
10126|      0|                    {
10127|      0|                      yyerror(p, "formal argument cannot be a global variable");
10128|      0|                      (yyval.nd) = 0;
10129|      0|                    }
10130|      0|#line 10131 "mrbgems/mruby-compiler/core/y.tab.c"
10131|      0|    break;
10132|       |
10133|      0|  case 548: /* f_bad_arg: "class variable"  */
  ------------------
  |  Branch (10133:3): [True: 0, False: 12.5M]
  ------------------
10134|      0|#line 3862 "mrbgems/mruby-compiler/core/parse.y"
10135|      0|                    {
10136|      0|                      yyerror(p, "formal argument cannot be a class variable");
10137|      0|                      (yyval.nd) = 0;
10138|      0|                    }
10139|      0|#line 10140 "mrbgems/mruby-compiler/core/y.tab.c"
10140|      0|    break;
10141|       |
10142|      0|  case 549: /* f_bad_arg: "numbered parameter"  */
  ------------------
  |  Branch (10142:3): [True: 0, False: 12.5M]
  ------------------
10143|      0|#line 3867 "mrbgems/mruby-compiler/core/parse.y"
10144|      0|                    {
10145|      0|                      yyerror(p, "formal argument cannot be a numbered parameter");
10146|      0|                      (yyval.nd) = 0;
10147|      0|                    }
10148|      0|#line 10149 "mrbgems/mruby-compiler/core/y.tab.c"
10149|      0|    break;
10150|       |
10151|      0|  case 550: /* f_norm_arg: f_bad_arg  */
  ------------------
  |  Branch (10151:3): [True: 0, False: 12.5M]
  ------------------
10152|      0|#line 3874 "mrbgems/mruby-compiler/core/parse.y"
10153|      0|                    {
10154|      0|                      (yyval.id) = 0;
10155|      0|                    }
10156|      0|#line 10157 "mrbgems/mruby-compiler/core/y.tab.c"
10157|      0|    break;
10158|       |
10159|      0|  case 551: /* f_norm_arg: "local variable or method"  */
  ------------------
  |  Branch (10159:3): [True: 0, False: 12.5M]
  ------------------
10160|      0|#line 3878 "mrbgems/mruby-compiler/core/parse.y"
10161|      0|                    {
10162|      0|                      local_add_f(p, (yyvsp[0].id));
10163|      0|                      (yyval.id) = (yyvsp[0].id);
10164|      0|                    }
10165|      0|#line 10166 "mrbgems/mruby-compiler/core/y.tab.c"
10166|      0|    break;
10167|       |
10168|      0|  case 552: /* f_arg_item: f_norm_arg  */
  ------------------
  |  Branch (10168:3): [True: 0, False: 12.5M]
  ------------------
10169|      0|#line 3885 "mrbgems/mruby-compiler/core/parse.y"
10170|      0|                    {
10171|      0|                      (yyval.nd) = new_arg(p, (yyvsp[0].id));
10172|      0|                    }
10173|      0|#line 10174 "mrbgems/mruby-compiler/core/y.tab.c"
10174|      0|    break;
10175|       |
10176|      0|  case 553: /* @32: %empty  */
  ------------------
  |  Branch (10176:3): [True: 0, False: 12.5M]
  ------------------
10177|      0|#line 3889 "mrbgems/mruby-compiler/core/parse.y"
10178|      0|                    {
10179|      0|                      (yyval.nd) = local_switch(p);
10180|      0|                    }
10181|      0|#line 10182 "mrbgems/mruby-compiler/core/y.tab.c"
10182|      0|    break;
10183|       |
10184|      0|  case 554: /* f_arg_item: tLPAREN @32 f_margs rparen  */
  ------------------
  |  Branch (10184:3): [True: 0, False: 12.5M]
  ------------------
10185|      0|#line 3893 "mrbgems/mruby-compiler/core/parse.y"
10186|      0|                    {
10187|      0|                      (yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car);
10188|      0|                      local_resume(p, (yyvsp[-2].nd));
10189|      0|                      local_add_f(p, 0);
10190|      0|                    }
10191|      0|#line 10192 "mrbgems/mruby-compiler/core/y.tab.c"
10192|      0|    break;
10193|       |
10194|      0|  case 555: /* f_arg: f_arg_item  */
  ------------------
  |  Branch (10194:3): [True: 0, False: 12.5M]
  ------------------
10195|      0|#line 3901 "mrbgems/mruby-compiler/core/parse.y"
10196|      0|                    {
10197|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
10198|      0|                    }
10199|      0|#line 10200 "mrbgems/mruby-compiler/core/y.tab.c"
10200|      0|    break;
10201|       |
10202|      0|  case 556: /* f_arg: f_arg ',' f_arg_item  */
  ------------------
  |  Branch (10202:3): [True: 0, False: 12.5M]
  ------------------
10203|      0|#line 3905 "mrbgems/mruby-compiler/core/parse.y"
10204|      0|                    {
10205|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
10206|      0|                    }
10207|      0|#line 10208 "mrbgems/mruby-compiler/core/y.tab.c"
10208|      0|    break;
10209|       |
10210|      0|  case 557: /* f_opt_asgn: "local variable or method" '='  */
  ------------------
  |  Branch (10210:3): [True: 0, False: 12.5M]
  ------------------
10211|      0|#line 3911 "mrbgems/mruby-compiler/core/parse.y"
10212|      0|                    {
10213|      0|                      local_add_f(p, (yyvsp[-1].id));
10214|      0|                      local_nest(p);
10215|      0|                      (yyval.id) = (yyvsp[-1].id);
10216|      0|                    }
10217|      0|#line 10218 "mrbgems/mruby-compiler/core/y.tab.c"
10218|      0|    break;
10219|       |
10220|      0|  case 558: /* f_opt: f_opt_asgn arg  */
  ------------------
  |  Branch (10220:3): [True: 0, False: 12.5M]
  ------------------
10221|      0|#line 3919 "mrbgems/mruby-compiler/core/parse.y"
10222|      0|                    {
10223|      0|                      void_expr_error(p, (yyvsp[0].nd));
10224|      0|                      (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10225|      0|                      local_unnest(p);
10226|      0|                    }
10227|      0|#line 10228 "mrbgems/mruby-compiler/core/y.tab.c"
10228|      0|    break;
10229|       |
10230|      0|  case 559: /* f_block_opt: f_opt_asgn primary_value  */
  ------------------
  |  Branch (10230:3): [True: 0, False: 12.5M]
  ------------------
10231|      0|#line 3927 "mrbgems/mruby-compiler/core/parse.y"
10232|      0|                    {
10233|      0|                      void_expr_error(p, (yyvsp[0].nd));
10234|      0|                      (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10235|      0|                      local_unnest(p);
10236|      0|                    }
10237|      0|#line 10238 "mrbgems/mruby-compiler/core/y.tab.c"
10238|      0|    break;
10239|       |
10240|      0|  case 560: /* f_block_optarg: f_block_opt  */
  ------------------
  |  Branch (10240:3): [True: 0, False: 12.5M]
  ------------------
10241|      0|#line 3935 "mrbgems/mruby-compiler/core/parse.y"
10242|      0|                    {
10243|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
10244|      0|                    }
10245|      0|#line 10246 "mrbgems/mruby-compiler/core/y.tab.c"
10246|      0|    break;
10247|       |
10248|      0|  case 561: /* f_block_optarg: f_block_optarg ',' f_block_opt  */
  ------------------
  |  Branch (10248:3): [True: 0, False: 12.5M]
  ------------------
10249|      0|#line 3939 "mrbgems/mruby-compiler/core/parse.y"
10250|      0|                    {
10251|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
10252|      0|                    }
10253|      0|#line 10254 "mrbgems/mruby-compiler/core/y.tab.c"
10254|      0|    break;
10255|       |
10256|      0|  case 562: /* f_optarg: f_opt  */
  ------------------
  |  Branch (10256:3): [True: 0, False: 12.5M]
  ------------------
10257|      0|#line 3945 "mrbgems/mruby-compiler/core/parse.y"
10258|      0|                    {
10259|      0|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  ------------------
10260|      0|                    }
10261|      0|#line 10262 "mrbgems/mruby-compiler/core/y.tab.c"
10262|      0|    break;
10263|       |
10264|      0|  case 563: /* f_optarg: f_optarg ',' f_opt  */
  ------------------
  |  Branch (10264:3): [True: 0, False: 12.5M]
  ------------------
10265|      0|#line 3949 "mrbgems/mruby-compiler/core/parse.y"
10266|      0|                    {
10267|      0|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
10268|      0|                    }
10269|      0|#line 10270 "mrbgems/mruby-compiler/core/y.tab.c"
10270|      0|    break;
10271|       |
10272|      0|  case 566: /* f_rest_arg: restarg_mark "local variable or method"  */
  ------------------
  |  Branch (10272:3): [True: 0, False: 12.5M]
  ------------------
10273|      0|#line 3959 "mrbgems/mruby-compiler/core/parse.y"
10274|      0|                    {
10275|      0|                      local_add_f(p, (yyvsp[0].id));
10276|      0|                      (yyval.id) = (yyvsp[0].id);
10277|      0|                    }
10278|      0|#line 10279 "mrbgems/mruby-compiler/core/y.tab.c"
10279|      0|    break;
10280|       |
10281|      0|  case 567: /* f_rest_arg: restarg_mark  */
  ------------------
  |  Branch (10281:3): [True: 0, False: 12.5M]
  ------------------
10282|      0|#line 3964 "mrbgems/mruby-compiler/core/parse.y"
10283|      0|                    {
10284|      0|                      (yyval.id) = intern_op(mul);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
10285|      0|                      local_add_f(p, (yyval.id));
10286|      0|                    }
10287|      0|#line 10288 "mrbgems/mruby-compiler/core/y.tab.c"
10288|      0|    break;
10289|       |
10290|      0|  case 570: /* f_block_arg: blkarg_mark "local variable or method"  */
  ------------------
  |  Branch (10290:3): [True: 0, False: 12.5M]
  ------------------
10291|      0|#line 3975 "mrbgems/mruby-compiler/core/parse.y"
10292|      0|                    {
10293|      0|                      (yyval.id) = (yyvsp[0].id);
10294|      0|                    }
10295|      0|#line 10296 "mrbgems/mruby-compiler/core/y.tab.c"
10296|      0|    break;
10297|       |
10298|      0|  case 571: /* f_block_arg: blkarg_mark  */
  ------------------
  |  Branch (10298:3): [True: 0, False: 12.5M]
  ------------------
10299|      0|#line 3979 "mrbgems/mruby-compiler/core/parse.y"
10300|      0|                    {
10301|      0|                      (yyval.id) = intern_op(and);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
10302|      0|                    }
10303|      0|#line 10304 "mrbgems/mruby-compiler/core/y.tab.c"
10304|      0|    break;
10305|       |
10306|      0|  case 572: /* opt_f_block_arg: ',' f_block_arg  */
  ------------------
  |  Branch (10306:3): [True: 0, False: 12.5M]
  ------------------
10307|      0|#line 3985 "mrbgems/mruby-compiler/core/parse.y"
10308|      0|                    {
10309|      0|                      (yyval.id) = (yyvsp[0].id);
10310|      0|                    }
10311|      0|#line 10312 "mrbgems/mruby-compiler/core/y.tab.c"
10312|      0|    break;
10313|       |
10314|      0|  case 573: /* opt_f_block_arg: none  */
  ------------------
  |  Branch (10314:3): [True: 0, False: 12.5M]
  ------------------
10315|      0|#line 3989 "mrbgems/mruby-compiler/core/parse.y"
10316|      0|                    {
10317|      0|                      (yyval.id) = 0;
10318|      0|                    }
10319|      0|#line 10320 "mrbgems/mruby-compiler/core/y.tab.c"
10320|      0|    break;
10321|       |
10322|      0|  case 574: /* singleton: var_ref  */
  ------------------
  |  Branch (10322:3): [True: 0, False: 12.5M]
  ------------------
10323|      0|#line 3995 "mrbgems/mruby-compiler/core/parse.y"
10324|      0|                    {
10325|      0|                      (yyval.nd) = (yyvsp[0].nd);
10326|      0|                      if (!(yyval.nd)) (yyval.nd) = new_nil(p);
  ------------------
  |  Branch (10326:27): [True: 0, False: 0]
  ------------------
10327|      0|                    }
10328|      0|#line 10329 "mrbgems/mruby-compiler/core/y.tab.c"
10329|      0|    break;
10330|       |
10331|      0|  case 575: /* $@33: %empty  */
  ------------------
  |  Branch (10331:3): [True: 0, False: 12.5M]
  ------------------
10332|      0|#line 3999 "mrbgems/mruby-compiler/core/parse.y"
10333|      0|                      {p->lstate = EXPR_BEG;}
10334|      0|#line 10335 "mrbgems/mruby-compiler/core/y.tab.c"
10335|      0|    break;
10336|       |
10337|      0|  case 576: /* singleton: '(' $@33 expr rparen  */
  ------------------
  |  Branch (10337:3): [True: 0, False: 12.5M]
  ------------------
10338|      0|#line 4000 "mrbgems/mruby-compiler/core/parse.y"
10339|      0|                    {
10340|      0|                      if ((yyvsp[-1].nd) == 0) {
  ------------------
  |  Branch (10340:27): [True: 0, False: 0]
  ------------------
10341|      0|                        yyerror(p, "can't define singleton method for ().");
10342|      0|                      }
10343|      0|                      else {
10344|      0|                        switch (typen((yyvsp[-1].nd)->car)) {
  ------------------
  |  |  136|      0|#define typen(x) ((enum node_type)(intptr_t)(x))
  ------------------
10345|      0|                        case NODE_STR:
  ------------------
  |  Branch (10345:25): [True: 0, False: 0]
  ------------------
10346|      0|                        case NODE_DSTR:
  ------------------
  |  Branch (10346:25): [True: 0, False: 0]
  ------------------
10347|      0|                        case NODE_XSTR:
  ------------------
  |  Branch (10347:25): [True: 0, False: 0]
  ------------------
10348|      0|                        case NODE_DXSTR:
  ------------------
  |  Branch (10348:25): [True: 0, False: 0]
  ------------------
10349|      0|                        case NODE_DREGX:
  ------------------
  |  Branch (10349:25): [True: 0, False: 0]
  ------------------
10350|      0|                        case NODE_MATCH:
  ------------------
  |  Branch (10350:25): [True: 0, False: 0]
  ------------------
10351|      0|                        case NODE_FLOAT:
  ------------------
  |  Branch (10351:25): [True: 0, False: 0]
  ------------------
10352|      0|                        case NODE_ARRAY:
  ------------------
  |  Branch (10352:25): [True: 0, False: 0]
  ------------------
10353|      0|                        case NODE_HEREDOC:
  ------------------
  |  Branch (10353:25): [True: 0, False: 0]
  ------------------
10354|      0|                          yyerror(p, "can't define singleton method for literals");
10355|      0|                        default:
  ------------------
  |  Branch (10355:25): [True: 0, False: 0]
  ------------------
10356|      0|                          break;
10357|      0|                        }
10358|      0|                      }
10359|      0|                      (yyval.nd) = (yyvsp[-1].nd);
10360|      0|                    }
10361|      0|#line 10362 "mrbgems/mruby-compiler/core/y.tab.c"
10362|      0|    break;
10363|       |
10364|  3.61k|  case 578: /* assoc_list: assocs trailer  */
  ------------------
  |  Branch (10364:3): [True: 3.61k, False: 12.5M]
  ------------------
10365|  3.61k|#line 4026 "mrbgems/mruby-compiler/core/parse.y"
10366|  3.61k|                    {
10367|  3.61k|                      (yyval.nd) = (yyvsp[-1].nd);
10368|  3.61k|                    }
10369|  3.61k|#line 10370 "mrbgems/mruby-compiler/core/y.tab.c"
10370|  3.61k|    break;
10371|       |
10372|  3.61k|  case 579: /* assocs: assoc  */
  ------------------
  |  Branch (10372:3): [True: 3.61k, False: 12.5M]
  ------------------
10373|  3.61k|#line 4032 "mrbgems/mruby-compiler/core/parse.y"
10374|  3.61k|                    {
10375|  3.61k|                      (yyval.nd) = list1((yyvsp[0].nd));
  ------------------
  |  |  217|  3.61k|#define list1(a) list1_gen(p, (a))
  ------------------
10376|  3.61k|                      NODE_LINENO((yyval.nd), (yyvsp[0].nd));
  ------------------
  |  |  125|  3.61k|#define NODE_LINENO(c,n) do {\
  |  |  126|  3.61k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 3.61k, False: 0]
  |  |  ------------------
  |  |  127|  3.61k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|  3.61k|     (c)->lineno = (n)->lineno;\
  |  |  129|  3.61k|  }\
  |  |  130|  3.61k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
10377|  3.61k|                    }
10378|  3.61k|#line 10379 "mrbgems/mruby-compiler/core/y.tab.c"
10379|  3.61k|    break;
10380|       |
10381|   125k|  case 580: /* assocs: assocs comma assoc  */
  ------------------
  |  Branch (10381:3): [True: 125k, False: 12.4M]
  ------------------
10382|   125k|#line 4037 "mrbgems/mruby-compiler/core/parse.y"
10383|   125k|                    {
10384|   125k|                      (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  268|   125k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|   125k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
10385|   125k|                    }
10386|   125k|#line 10387 "mrbgems/mruby-compiler/core/y.tab.c"
10387|   125k|    break;
10388|       |
10389|   129k|  case 581: /* assoc: arg "=>" arg  */
  ------------------
  |  Branch (10389:3): [True: 129k, False: 12.4M]
  ------------------
10390|   129k|#line 4043 "mrbgems/mruby-compiler/core/parse.y"
10391|   129k|                    {
10392|   129k|                      void_expr_error(p, (yyvsp[-2].nd));
10393|   129k|                      void_expr_error(p, (yyvsp[0].nd));
10394|   129k|                      (yyval.nd) = cons((yyvsp[-2].nd), (yyvsp[0].nd));
  ------------------
  |  |  210|   129k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10395|   129k|                    }
10396|   129k|#line 10397 "mrbgems/mruby-compiler/core/y.tab.c"
10397|   129k|    break;
10398|       |
10399|      0|  case 582: /* assoc: "local variable or method" "label" arg  */
  ------------------
  |  Branch (10399:3): [True: 0, False: 12.5M]
  ------------------
10400|      0|#line 4049 "mrbgems/mruby-compiler/core/parse.y"
10401|      0|                    {
10402|      0|                      void_expr_error(p, (yyvsp[0].nd));
10403|      0|                      (yyval.nd) = cons(new_sym(p, (yyvsp[-2].id)), (yyvsp[0].nd));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10404|      0|                    }
10405|      0|#line 10406 "mrbgems/mruby-compiler/core/y.tab.c"
10406|      0|    break;
10407|       |
10408|      0|  case 583: /* assoc: "local variable or method" "label"  */
  ------------------
  |  Branch (10408:3): [True: 0, False: 12.5M]
  ------------------
10409|      0|#line 4054 "mrbgems/mruby-compiler/core/parse.y"
10410|      0|                    {
10411|      0|                      (yyval.nd) = cons(new_sym(p, (yyvsp[-1].id)), label_reference(p, (yyvsp[-1].id)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10412|      0|                    }
10413|      0|#line 10414 "mrbgems/mruby-compiler/core/y.tab.c"
10414|      0|    break;
10415|       |
10416|      0|  case 584: /* assoc: "numbered parameter" "label"  */
  ------------------
  |  Branch (10416:3): [True: 0, False: 12.5M]
  ------------------
10417|      0|#line 4058 "mrbgems/mruby-compiler/core/parse.y"
10418|      0|                    {
10419|      0|                      mrb_sym sym = intern_numparam((yyvsp[-1].num));
  ------------------
  |  |  164|      0|#define intern_numparam(n) intern_numparam_gen(p,(n))
  ------------------
10420|      0|                      (yyval.nd) = cons(new_sym(p, sym), label_reference(p, sym));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10421|      0|                    }
10422|      0|#line 10423 "mrbgems/mruby-compiler/core/y.tab.c"
10423|      0|    break;
10424|       |
10425|      0|  case 585: /* assoc: "numbered parameter" "label" arg  */
  ------------------
  |  Branch (10425:3): [True: 0, False: 12.5M]
  ------------------
10426|      0|#line 4063 "mrbgems/mruby-compiler/core/parse.y"
10427|      0|                    {
10428|      0|                      void_expr_error(p, (yyvsp[0].nd));
10429|      0|                      (yyval.nd) = cons(new_sym(p, intern_numparam((yyvsp[-2].num))), (yyvsp[0].nd));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10430|      0|                    }
10431|      0|#line 10432 "mrbgems/mruby-compiler/core/y.tab.c"
10432|      0|    break;
10433|       |
10434|      0|  case 586: /* assoc: string_fragment "label" arg  */
  ------------------
  |  Branch (10434:3): [True: 0, False: 12.5M]
  ------------------
10435|      0|#line 4068 "mrbgems/mruby-compiler/core/parse.y"
10436|      0|                    {
10437|      0|                      void_expr_error(p, (yyvsp[0].nd));
10438|      0|                      if (typen((yyvsp[-2].nd)->car) == NODE_DSTR) {
  ------------------
  |  |  136|      0|#define typen(x) ((enum node_type)(intptr_t)(x))
  ------------------
  |  Branch (10438:27): [True: 0, False: 0]
  ------------------
10439|      0|                        (yyval.nd) = cons(new_dsym(p, (yyvsp[-2].nd)), (yyvsp[0].nd));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10440|      0|                      }
10441|      0|                      else {
10442|      0|                        (yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10443|      0|                      }
10444|      0|                    }
10445|      0|#line 10446 "mrbgems/mruby-compiler/core/y.tab.c"
10446|      0|    break;
10447|       |
10448|      0|  case 587: /* assoc: "**" arg  */
  ------------------
  |  Branch (10448:3): [True: 0, False: 12.5M]
  ------------------
10449|      0|#line 4078 "mrbgems/mruby-compiler/core/parse.y"
10450|      0|                    {
10451|      0|                      void_expr_error(p, (yyvsp[0].nd));
10452|      0|                      (yyval.nd) = cons(new_kw_rest_args(p, 0), (yyvsp[0].nd));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10453|      0|                    }
10454|      0|#line 10455 "mrbgems/mruby-compiler/core/y.tab.c"
10455|      0|    break;
10456|       |
10457|      0|  case 588: /* assoc: "**"  */
  ------------------
  |  Branch (10457:3): [True: 0, False: 12.5M]
  ------------------
10458|      0|#line 4083 "mrbgems/mruby-compiler/core/parse.y"
10459|      0|                    {
10460|      0|                      (yyval.nd) = cons(new_kw_rest_args(p, 0), new_lvar(p, intern_op(pow)));
  ------------------
  |  |  210|      0|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10461|      0|                    }
10462|      0|#line 10463 "mrbgems/mruby-compiler/core/y.tab.c"
10463|      0|    break;
10464|       |
10465|  95.8k|  case 601: /* call_op: '.'  */
  ------------------
  |  Branch (10465:3): [True: 95.8k, False: 12.4M]
  ------------------
10466|  95.8k|#line 4109 "mrbgems/mruby-compiler/core/parse.y"
10467|  95.8k|                    {
10468|  95.8k|                      (yyval.num) = '.';
10469|  95.8k|                    }
10470|  95.8k|#line 10471 "mrbgems/mruby-compiler/core/y.tab.c"
10471|  95.8k|    break;
10472|       |
10473|      0|  case 602: /* call_op: "&."  */
  ------------------
  |  Branch (10473:3): [True: 0, False: 12.5M]
  ------------------
10474|      0|#line 4113 "mrbgems/mruby-compiler/core/parse.y"
10475|      0|                    {
10476|      0|                      (yyval.num) = 0;
10477|      0|                    }
10478|      0|#line 10479 "mrbgems/mruby-compiler/core/y.tab.c"
10479|      0|    break;
10480|       |
10481|      0|  case 604: /* call_op2: "::"  */
  ------------------
  |  Branch (10481:3): [True: 0, False: 12.5M]
  ------------------
10482|      0|#line 4120 "mrbgems/mruby-compiler/core/parse.y"
10483|      0|                    {
10484|      0|                      (yyval.num) = tCOLON2;
10485|      0|                    }
10486|      0|#line 10487 "mrbgems/mruby-compiler/core/y.tab.c"
10487|      0|    break;
10488|       |
10489|      0|  case 613: /* term: ';'  */
  ------------------
  |  Branch (10489:3): [True: 0, False: 12.5M]
  ------------------
10490|      0|#line 4141 "mrbgems/mruby-compiler/core/parse.y"
10491|      0|                      {yyerrok;}
  ------------------
  |  | 5748|      0|#define yyerrok         (yyerrstatus = 0)
  ------------------
10492|      0|#line 10493 "mrbgems/mruby-compiler/core/y.tab.c"
10493|      0|    break;
10494|       |
10495|   412k|  case 615: /* nl: '\n'  */
  ------------------
  |  Branch (10495:3): [True: 412k, False: 12.1M]
  ------------------
10496|   412k|#line 4146 "mrbgems/mruby-compiler/core/parse.y"
10497|   412k|                    {
10498|   412k|                      p->lineno += (yyvsp[0].num);
10499|   412k|                      p->column = 0;
10500|   412k|                    }
10501|   412k|#line 10502 "mrbgems/mruby-compiler/core/y.tab.c"
10502|   412k|    break;
10503|       |
10504|   232k|  case 619: /* none: %empty  */
  ------------------
  |  Branch (10504:3): [True: 232k, False: 12.3M]
  ------------------
10505|   232k|#line 4158 "mrbgems/mruby-compiler/core/parse.y"
10506|   232k|                    {
10507|   232k|                      (yyval.nd) = 0;
10508|   232k|                    }
10509|   232k|#line 10510 "mrbgems/mruby-compiler/core/y.tab.c"
10510|   232k|    break;
10511|       |
10512|       |
10513|      0|#line 10514 "mrbgems/mruby-compiler/core/y.tab.c"
10514|       |
10515|  6.39M|      default: break;
  ------------------
  |  Branch (10515:7): [True: 6.39M, False: 6.14M]
  ------------------
10516|  12.5M|    }
10517|       |  /* User semantic actions sometimes alter yychar, and that requires
10518|       |     that yytoken be updated with the new translation.  We take the
10519|       |     approach of translating immediately before every use of yytoken.
10520|       |     One alternative is translating here after every semantic action,
10521|       |     but that translation would be missed if the semantic action invokes
10522|       |     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10523|       |     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
10524|       |     incorrect destructor might then be invoked immediately.  In the
10525|       |     case of YYERROR or YYBACKUP, subsequent parser actions might lead
10526|       |     to an incorrect destructor call or verbose syntax error message
10527|       |     before the lookahead is translated.  */
10528|  12.5M|  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
10529|       |
10530|  12.5M|  YYPOPSTACK (yylen);
  ------------------
  |  | 6275|  12.5M|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  ------------------
10531|  12.5M|  yylen = 0;
10532|       |
10533|  12.5M|  *++yyvsp = yyval;
10534|       |
10535|       |  /* Now 'shift' the result of the reduction.  Determine what state
10536|       |     that goes to, based on the state we popped back to and the rule
10537|       |     number reduced by.  */
10538|  12.5M|  {
10539|  12.5M|    const int yylhs = yyr1[yyn] - YYNTOKENS;
  ------------------
  |  | 2363|  12.5M|#define YYNTOKENS  149
  ------------------
10540|  12.5M|    const int yyi = yypgoto[yylhs] + *yyssp;
10541|  12.5M|    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
  ------------------
  |  | 2360|  22.4M|#define YYLAST   13092
  ------------------
  |  Branch (10541:16): [True: 9.90M, False: 2.64M]
  |  Branch (10541:28): [True: 9.90M, False: 0]
  |  Branch (10541:45): [True: 5.08M, False: 4.81M]
  ------------------
10542|  12.5M|               ? yytable[yyi]
10543|  12.5M|               : yydefgoto[yylhs]);
10544|  12.5M|  }
10545|       |
10546|  12.5M|  goto yynewstate;
10547|       |
10548|       |
10549|       |/*--------------------------------------.
10550|       || yyerrlab -- here on detecting error.  |
10551|       |`--------------------------------------*/
10552|      0|yyerrlab:
10553|       |  /* Make sure we have latest lookahead translation.  See comments at
10554|       |     user semantic actions for why this is necessary.  */
10555|      0|  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
  ------------------
  |  | 2378|      0|  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
  |  |  ------------------
  |  |  |  | 2372|      0|#define YYMAXUTOK   377
  |  |  ------------------
  |  |  |  Branch (2378:4): [True: 0, False: 0]
  |  |  |  Branch (2378:18): [True: 0, False: 0]
  |  |  ------------------
  |  | 2379|      0|   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
  |  |  ------------------
  |  |  |  | 1519|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  |  | 2380|      0|   : YYSYMBOL_YYUNDEF)
  ------------------
  |  Branch (10555:13): [True: 0, False: 0]
  ------------------
10556|       |  /* If not already recovering from an error, report this error.  */
10557|      0|  if (!yyerrstatus)
  ------------------
  |  Branch (10557:7): [True: 0, False: 0]
  ------------------
10558|      0|    {
10559|      0|      ++yynerrs;
10560|      0|      {
10561|      0|        yypcontext_t yyctx
10562|      0|          = {yyssp, yytoken};
10563|      0|        char const *yymsgp = YY_("syntax error");
  ------------------
  |  | 2162|      0|#  define YY_(Msgid) Msgid
  ------------------
10564|      0|        int yysyntax_error_status;
10565|      0|        yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
10566|      0|        if (yysyntax_error_status == 0)
  ------------------
  |  Branch (10566:13): [True: 0, False: 0]
  ------------------
10567|      0|          yymsgp = yymsg;
10568|      0|        else if (yysyntax_error_status == -1)
  ------------------
  |  Branch (10568:18): [True: 0, False: 0]
  ------------------
10569|      0|          {
10570|      0|            if (yymsg != yymsgbuf)
  ------------------
  |  Branch (10570:17): [True: 0, False: 0]
  ------------------
10571|      0|              YYSTACK_FREE (yymsg);
  ------------------
  |  | 2260|      0|#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  |  |  ------------------
  |  |  |  Branch (2260:56): [Folded - Ignored]
  |  |  ------------------
  ------------------
10572|      0|            yymsg = YY_CAST (char *,
  ------------------
  |  | 1519|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  ------------------
10573|      0|                             YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
10574|      0|            if (yymsg)
  ------------------
  |  Branch (10574:17): [True: 0, False: 0]
  ------------------
10575|      0|              {
10576|      0|                yysyntax_error_status
10577|      0|                  = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
10578|      0|                yymsgp = yymsg;
10579|      0|              }
10580|      0|            else
10581|      0|              {
10582|      0|                yymsg = yymsgbuf;
10583|      0|                yymsg_alloc = sizeof yymsgbuf;
10584|      0|                yysyntax_error_status = YYENOMEM;
10585|      0|              }
10586|      0|          }
10587|      0|        yyerror (p, yymsgp);
10588|      0|        if (yysyntax_error_status == YYENOMEM)
  ------------------
  |  Branch (10588:13): [True: 0, False: 0]
  ------------------
10589|      0|          YYNOMEM;
  ------------------
  |  | 5754|      0|#define YYNOMEM         goto yyexhaustedlab
  ------------------
10590|      0|      }
10591|      0|    }
10592|       |
10593|      0|  if (yyerrstatus == 3)
  ------------------
  |  Branch (10593:7): [True: 0, False: 0]
  ------------------
10594|      0|    {
10595|       |      /* If just tried and failed to reuse lookahead token after an
10596|       |         error, discard it.  */
10597|       |
10598|      0|      if (yychar <= YYEOF)
  ------------------
  |  Branch (10598:11): [True: 0, False: 0]
  ------------------
10599|      0|        {
10600|       |          /* Return failure if at end of input.  */
10601|      0|          if (yychar == YYEOF)
  ------------------
  |  Branch (10601:15): [True: 0, False: 0]
  ------------------
10602|      0|            YYABORT;
  ------------------
  |  | 5752|      0|#define YYABORT         goto yyabortlab
  ------------------
10603|      0|        }
10604|      0|      else
10605|      0|        {
10606|      0|          yydestruct ("Error: discarding",
10607|      0|                      yytoken, &yylval, p);
10608|      0|          yychar = YYEMPTY;
10609|      0|        }
10610|      0|    }
10611|       |
10612|       |  /* Else will try to reuse lookahead token after shifting the error
10613|       |     token.  */
10614|      0|  goto yyerrlab1;
10615|       |
10616|       |
10617|       |/*---------------------------------------------------.
10618|       || yyerrorlab -- error raised explicitly by YYERROR.  |
10619|       |`---------------------------------------------------*/
10620|      0|yyerrorlab:
10621|       |  /* Pacify compilers when the user code never invokes YYERROR and the
10622|       |     label yyerrorlab therefore never appears in user code.  */
10623|      0|  if (0)
  ------------------
  |  Branch (10623:7): [Folded - Ignored]
  ------------------
10624|      0|    YYERROR;
  ------------------
  |  | 5753|      0|#define YYERROR         goto yyerrorlab
  ------------------
10625|      0|  ++yynerrs;
10626|       |
10627|       |  /* Do not reclaim the symbols of the rule whose action triggered
10628|       |     this YYERROR.  */
10629|      0|  YYPOPSTACK (yylen);
  ------------------
  |  | 6275|      0|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  ------------------
10630|      0|  yylen = 0;
10631|      0|  YY_STACK_PRINT (yyss, yyssp);
10632|      0|  yystate = *yyssp;
10633|      0|  goto yyerrlab1;
10634|       |
10635|       |
10636|       |/*-------------------------------------------------------------.
10637|       || yyerrlab1 -- common code for both syntax error and YYERROR.  |
10638|       |`-------------------------------------------------------------*/
10639|      0|yyerrlab1:
10640|      0|  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
10641|       |
10642|       |  /* Pop stack until we find a state that shifts the error token.  */
10643|      0|  for (;;)
10644|      0|    {
10645|      0|      yyn = yypact[yystate];
10646|      0|      if (!yypact_value_is_default (yyn))
  ------------------
  |  | 2581|      0|  ((Yyn) == YYPACT_NINF)
  |  |  ------------------
  |  |  |  | 2578|      0|#define YYPACT_NINF (-868)
  |  |  ------------------
  ------------------
  |  Branch (10646:11): [True: 0, False: 0]
  ------------------
10647|      0|        {
10648|      0|          yyn += YYSYMBOL_YYerror;
10649|      0|          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
  ------------------
  |  | 2360|      0|#define YYLAST   13092
  ------------------
  |  Branch (10649:15): [True: 0, False: 0]
  |  Branch (10649:27): [True: 0, False: 0]
  |  Branch (10649:44): [True: 0, False: 0]
  ------------------
10650|      0|            {
10651|      0|              yyn = yytable[yyn];
10652|      0|              if (0 < yyn)
  ------------------
  |  Branch (10652:19): [True: 0, False: 0]
  ------------------
10653|      0|                break;
10654|      0|            }
10655|      0|        }
10656|       |
10657|       |      /* Pop the current state because it cannot handle the error token.  */
10658|      0|      if (yyssp == yyss)
  ------------------
  |  Branch (10658:11): [True: 0, False: 0]
  ------------------
10659|      0|        YYABORT;
  ------------------
  |  | 5752|      0|#define YYABORT         goto yyabortlab
  ------------------
10660|       |
10661|       |
10662|      0|      yydestruct ("Error: popping",
10663|      0|                  YY_ACCESSING_SYMBOL (yystate), yyvsp, p);
  ------------------
  |  | 2496|      0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
  |  |  ------------------
  |  |  |  | 1519|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  ------------------
10664|      0|      YYPOPSTACK (1);
  ------------------
  |  | 6275|      0|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  ------------------
10665|      0|      yystate = *yyssp;
10666|      0|      YY_STACK_PRINT (yyss, yyssp);
10667|      0|    }
10668|       |
10669|      0|  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
10670|      0|  *++yyvsp = yylval;
10671|      0|  YY_IGNORE_MAYBE_UNINITIALIZED_END
10672|       |
10673|       |
10674|       |  /* Shift the error token.  */
10675|      0|  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
10676|       |
10677|      0|  yystate = yyn;
10678|      0|  goto yynewstate;
10679|       |
10680|       |
10681|       |/*-------------------------------------.
10682|       || yyacceptlab -- YYACCEPT comes here.  |
10683|       |`-------------------------------------*/
10684|  1.74k|yyacceptlab:
10685|  1.74k|  yyresult = 0;
10686|  1.74k|  goto yyreturnlab;
10687|       |
10688|       |
10689|       |/*-----------------------------------.
10690|       || yyabortlab -- YYABORT comes here.  |
10691|       |`-----------------------------------*/
10692|      0|yyabortlab:
10693|      0|  yyresult = 1;
10694|      0|  goto yyreturnlab;
10695|       |
10696|       |
10697|       |/*-----------------------------------------------------------.
10698|       || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
10699|       |`-----------------------------------------------------------*/
10700|      0|yyexhaustedlab:
10701|      0|  yyerror (p, YY_("memory exhausted"));
  ------------------
  |  | 2162|      0|#  define YY_(Msgid) Msgid
  ------------------
10702|      0|  yyresult = 2;
10703|      0|  goto yyreturnlab;
10704|       |
10705|       |
10706|       |/*----------------------------------------------------------.
10707|       || yyreturnlab -- parsing is finished, clean up and return.  |
10708|       |`----------------------------------------------------------*/
10709|  1.74k|yyreturnlab:
10710|  1.74k|  if (yychar != YYEMPTY)
  ------------------
  |  Branch (10710:7): [True: 0, False: 1.74k]
  ------------------
10711|      0|    {
10712|       |      /* Make sure we have latest lookahead translation.  See comments at
10713|       |         user semantic actions for why this is necessary.  */
10714|      0|      yytoken = YYTRANSLATE (yychar);
  ------------------
  |  | 2378|      0|  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
  |  |  ------------------
  |  |  |  | 2372|      0|#define YYMAXUTOK   377
  |  |  ------------------
  |  |  |  Branch (2378:4): [True: 0, False: 0]
  |  |  |  Branch (2378:18): [True: 0, False: 0]
  |  |  ------------------
  |  | 2379|      0|   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
  |  |  ------------------
  |  |  |  | 1519|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  |  | 2380|      0|   : YYSYMBOL_YYUNDEF)
  ------------------
10715|      0|      yydestruct ("Cleanup: discarding lookahead",
10716|      0|                  yytoken, &yylval, p);
10717|      0|    }
10718|       |  /* Do not reclaim the symbols of the rule whose action triggered
10719|       |     this YYABORT or YYACCEPT.  */
10720|  1.74k|  YYPOPSTACK (yylen);
  ------------------
  |  | 6275|  1.74k|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  ------------------
10721|  1.74k|  YY_STACK_PRINT (yyss, yyssp);
10722|  5.23k|  while (yyssp != yyss)
  ------------------
  |  Branch (10722:10): [True: 3.49k, False: 1.74k]
  ------------------
10723|  3.49k|    {
10724|  3.49k|      yydestruct ("Cleanup: popping",
10725|  3.49k|                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, p);
  ------------------
  |  | 2496|  3.49k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
  |  |  ------------------
  |  |  |  | 1519|  3.49k|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  ------------------
10726|  3.49k|      YYPOPSTACK (1);
  ------------------
  |  | 6275|  3.49k|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  ------------------
10727|  3.49k|    }
10728|  1.74k|#ifndef yyoverflow
10729|  1.74k|  if (yyss != yyssa)
  ------------------
  |  Branch (10729:7): [True: 3, False: 1.74k]
  ------------------
10730|      3|    YYSTACK_FREE (yyss);
  ------------------
  |  | 2260|      3|#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  |  |  ------------------
  |  |  |  Branch (2260:56): [Folded - Ignored]
  |  |  ------------------
  ------------------
10731|  1.74k|#endif
10732|  1.74k|  if (yymsg != yymsgbuf)
  ------------------
  |  Branch (10732:7): [True: 0, False: 1.74k]
  ------------------
10733|      0|    YYSTACK_FREE (yymsg);
  ------------------
  |  | 2260|      0|#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  |  |  ------------------
  |  |  |  Branch (2260:56): [Folded - Ignored]
  |  |  ------------------
  ------------------
10734|  1.74k|  return yyresult;
10735|      0|}
y.tab.c:yylex:
13161|  3.88M|{
13162|  3.88M|  p->ylval = lval;
13163|  3.88M|  return parser_yylex(p);
13164|  3.88M|}
y.tab.c:parser_yylex:
11830|  3.88M|{
11831|  3.88M|  int32_t c;
11832|  3.88M|  int nlines = 1;
11833|  3.88M|  int space_seen = 0;
11834|  3.88M|  int cmd_state;
11835|  3.88M|  enum mrb_lex_state_enum last_state;
11836|  3.88M|  int token_column;
11837|       |
11838|  3.88M|  if (p->lex_strterm) {
  ------------------
  |  Branch (11838:7): [True: 258k, False: 3.63M]
  ------------------
11839|   258k|    if (is_strterm_type(p, STR_FUNC_HEREDOC)) {
  ------------------
  |  | 1507|   258k|#define is_strterm_type(p,str_func) ((p)->lex_strterm->type & (str_func))
  |  |  ------------------
  |  |  |  Branch (1507:37): [True: 0, False: 258k]
  |  |  ------------------
  ------------------
11840|      0|      if (p->parsing_heredoc != NULL)
  ------------------
  |  Branch (11840:11): [True: 0, False: 0]
  ------------------
11841|      0|        return parse_string(p);
11842|      0|    }
11843|   258k|    else
11844|   258k|      return parse_string(p);
11845|   258k|  }
11846|  3.63M|  cmd_state = p->cmd_start;
11847|  3.63M|  p->cmd_start = FALSE;
  ------------------
  |  |   51|  3.63M|#  define FALSE 0
  ------------------
11848|  5.72M|  retry:
11849|  5.72M|  last_state = p->lstate;
11850|  5.72M|  switch (c = nextc(p)) {
11851|      0|  case '\004':  /* ^D */
  ------------------
  |  Branch (11851:3): [True: 0, False: 5.72M]
  ------------------
11852|      0|  case '\032':  /* ^Z */
  ------------------
  |  Branch (11852:3): [True: 0, False: 5.72M]
  ------------------
11853|      0|  case '\0':    /* NUL */
  ------------------
  |  Branch (11853:3): [True: 0, False: 5.72M]
  ------------------
11854|  1.74k|  case -1:      /* end of script. */
  ------------------
  |  Branch (11854:3): [True: 1.74k, False: 5.72M]
  ------------------
11855|  1.74k|    if (p->heredocs_from_nextline)
  ------------------
  |  Branch (11855:9): [True: 0, False: 1.74k]
  ------------------
11856|      0|      goto maybe_heredoc;
11857|  1.74k|    return 0;
11858|       |
11859|       |  /* white spaces */
11860|  1.43M|  case ' ': case '\t': case '\f': case '\r':
  ------------------
  |  Branch (11860:3): [True: 1.43M, False: 4.29M]
  |  Branch (11860:13): [True: 0, False: 5.72M]
  |  Branch (11860:24): [True: 0, False: 5.72M]
  |  Branch (11860:35): [True: 0, False: 5.72M]
  ------------------
11861|  1.43M|  case '\13':   /* '\v' */
  ------------------
  |  Branch (11861:3): [True: 0, False: 5.72M]
  ------------------
11862|  1.43M|    space_seen = 1;
11863|  1.43M|    goto retry;
11864|       |
11865|      0|  case '#':     /* it's a comment */
  ------------------
  |  Branch (11865:3): [True: 0, False: 5.72M]
  ------------------
11866|      0|    skip(p, '\n');
11867|       |    /* fall through */
11868|      0|  case -2:      /* end of a file */
  ------------------
  |  Branch (11868:3): [True: 0, False: 5.72M]
  ------------------
11869|  1.07M|  case '\n':
  ------------------
  |  Branch (11869:3): [True: 1.07M, False: 4.64M]
  ------------------
11870|  1.07M|  maybe_heredoc:
11871|  1.07M|    heredoc_treat_nextline(p);
11872|  1.07M|    p->column = 0;
11873|  1.07M|    switch (p->lstate) {
11874|   666k|    case EXPR_BEG:
  ------------------
  |  Branch (11874:5): [True: 666k, False: 412k]
  ------------------
11875|   666k|    case EXPR_FNAME:
  ------------------
  |  Branch (11875:5): [True: 0, False: 1.07M]
  ------------------
11876|   666k|    case EXPR_DOT:
  ------------------
  |  Branch (11876:5): [True: 0, False: 1.07M]
  ------------------
11877|   666k|    case EXPR_CLASS:
  ------------------
  |  Branch (11877:5): [True: 0, False: 1.07M]
  ------------------
11878|   666k|    case EXPR_VALUE:
  ------------------
  |  Branch (11878:5): [True: 0, False: 1.07M]
  ------------------
11879|   666k|      p->lineno++;
11880|   666k|      if (p->parsing_heredoc != NULL) {
  ------------------
  |  Branch (11880:11): [True: 0, False: 666k]
  ------------------
11881|      0|        if (p->lex_strterm) {
  ------------------
  |  Branch (11881:13): [True: 0, False: 0]
  ------------------
11882|      0|          return parse_string(p);
11883|      0|        }
11884|      0|      }
11885|   666k|      goto retry;
11886|   666k|    default:
  ------------------
  |  Branch (11886:5): [True: 412k, False: 666k]
  ------------------
11887|   412k|      break;
11888|  1.07M|    }
11889|   412k|    if (p->parsing_heredoc != NULL) {
  ------------------
  |  Branch (11889:9): [True: 0, False: 412k]
  ------------------
11890|      0|      pylval.num = nlines;
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11891|      0|      return '\n';
11892|      0|    }
11893|   412k|    while ((c = nextc(p))) {
  ------------------
  |  Branch (11893:12): [True: 412k, False: 0]
  ------------------
11894|   412k|      switch (c) {
11895|      0|      case ' ': case '\t': case '\f': case '\r':
  ------------------
  |  Branch (11895:7): [True: 0, False: 412k]
  |  Branch (11895:17): [True: 0, False: 412k]
  |  Branch (11895:28): [True: 0, False: 412k]
  |  Branch (11895:39): [True: 0, False: 412k]
  ------------------
11896|      0|      case '\13': /* '\v' */
  ------------------
  |  Branch (11896:7): [True: 0, False: 412k]
  ------------------
11897|      0|        space_seen = 1;
11898|      0|        break;
11899|      0|      case '#': /* comment as a whitespace */
  ------------------
  |  Branch (11899:7): [True: 0, False: 412k]
  ------------------
11900|      0|        skip(p, '\n');
11901|      0|        nlines++;
11902|      0|        break;
11903|      0|      case '.':
  ------------------
  |  Branch (11903:7): [True: 0, False: 412k]
  ------------------
11904|      0|        if (!peek(p, '.')) {
  ------------------
  |  |10981|      0|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
  |  Branch (11904:13): [True: 0, False: 0]
  ------------------
11905|      0|          pushback(p, '.');
11906|      0|          p->lineno+=nlines; nlines=1;
11907|      0|          goto retry;
11908|      0|        }
11909|      0|        pushback(p, c);
11910|      0|        goto normal_newline;
11911|      0|      case '&':
  ------------------
  |  Branch (11911:7): [True: 0, False: 412k]
  ------------------
11912|      0|        if (peek(p, '.')) {
  ------------------
  |  |10981|      0|#define peek(p,c) peek_n((p), (c), 0)
  |  |  ------------------
  |  |  |  Branch (10981:19): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11913|      0|          pushback(p, '&');
11914|      0|          p->lineno+=nlines; nlines=1;
11915|      0|          goto retry;
11916|      0|        }
11917|      0|        pushback(p, c);
11918|      0|        goto normal_newline;
11919|  1.74k|      case -1:                  /* EOF */
  ------------------
  |  Branch (11919:7): [True: 1.74k, False: 410k]
  ------------------
11920|  1.74k|      case -2:                  /* end of a file */
  ------------------
  |  Branch (11920:7): [True: 0, False: 412k]
  ------------------
11921|  1.74k|        goto normal_newline;
11922|   410k|      default:
  ------------------
  |  Branch (11922:7): [True: 410k, False: 1.74k]
  ------------------
11923|   410k|        pushback(p, c);
11924|   410k|        goto normal_newline;
11925|   412k|      }
11926|   412k|    }
11927|   412k|  normal_newline:
11928|   412k|    p->cmd_start = TRUE;
  ------------------
  |  |   54|   412k|#  define TRUE 1
  ------------------
11929|   412k|    p->lstate = EXPR_BEG;
11930|   412k|    pylval.num = nlines;
  ------------------
  |  |10739|   412k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11931|   412k|    return '\n';
11932|       |
11933|  18.2k|  case '*':
  ------------------
  |  Branch (11933:3): [True: 18.2k, False: 5.70M]
  ------------------
11934|  18.2k|    if ((c = nextc(p)) == '*') {
  ------------------
  |  Branch (11934:9): [True: 0, False: 18.2k]
  ------------------
11935|      0|      if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (11935:11): [True: 0, False: 0]
  ------------------
11936|      0|        pylval.id = intern_op(pow);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                      pylval.id = intern_op(pow);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
11937|      0|        p->lstate = EXPR_BEG;
11938|      0|        return tOP_ASGN;
11939|      0|      }
11940|      0|      pushback(p, c);
11941|      0|      if (IS_SPCARG(c)) {
  ------------------
  |  |11140|      0|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|      0|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 0]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11942|      0|        yywarning(p, "'**' interpreted as argument prefix");
11943|      0|        c = tDSTAR;
11944|      0|      }
11945|      0|      else if (IS_BEG()) {
  ------------------
  |  |11139|      0|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 0]
  |  |  |  Branch (11139:44): [True: 0, False: 0]
  |  |  |  Branch (11139:69): [True: 0, False: 0]
  |  |  |  Branch (11139:96): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11946|      0|        c = tDSTAR;
11947|      0|      }
11948|      0|      else {
11949|      0|        c = tPOW; /* "**", "argument prefix" */
11950|      0|      }
11951|      0|    }
11952|  18.2k|    else {
11953|  18.2k|      if (c == '=') {
  ------------------
  |  Branch (11953:11): [True: 0, False: 18.2k]
  ------------------
11954|      0|        pylval.id = intern_op(mul);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                      pylval.id = intern_op(mul);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
11955|      0|        p->lstate = EXPR_BEG;
11956|      0|        return tOP_ASGN;
11957|      0|      }
11958|  18.2k|      pushback(p, c);
11959|  18.2k|      if (IS_SPCARG(c)) {
  ------------------
  |  |11140|  18.2k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|  36.4k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 18.2k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 18.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11960|      0|        yywarning(p, "'*' interpreted as argument prefix");
11961|      0|        c = tSTAR;
11962|      0|      }
11963|  18.2k|      else if (IS_BEG()) {
  ------------------
  |  |11139|  18.2k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 18.2k]
  |  |  |  Branch (11139:44): [True: 0, False: 18.2k]
  |  |  |  Branch (11139:69): [True: 0, False: 18.2k]
  |  |  |  Branch (11139:96): [True: 0, False: 18.2k]
  |  |  ------------------
  ------------------
11964|      0|        c = tSTAR;
11965|      0|      }
11966|  18.2k|      else {
11967|  18.2k|        c = '*';
11968|  18.2k|      }
11969|  18.2k|    }
11970|  18.2k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (11970:9): [True: 0, False: 18.2k]
  |  Branch (11970:36): [True: 0, False: 18.2k]
  ------------------
11971|      0|      p->lstate = EXPR_ARG;
11972|      0|    }
11973|  18.2k|    else {
11974|  18.2k|      p->lstate = EXPR_BEG;
11975|  18.2k|    }
11976|  18.2k|    return c;
11977|       |
11978|  6.40k|  case '!':
  ------------------
  |  Branch (11978:3): [True: 6.40k, False: 5.72M]
  ------------------
11979|  6.40k|    c = nextc(p);
11980|  6.40k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (11980:9): [True: 0, False: 6.40k]
  |  Branch (11980:36): [True: 0, False: 6.40k]
  ------------------
11981|      0|      p->lstate = EXPR_ARG;
11982|      0|      if (c == '@') {
  ------------------
  |  Branch (11982:11): [True: 0, False: 0]
  ------------------
11983|      0|        return '!';
11984|      0|      }
11985|      0|    }
11986|  6.40k|    else {
11987|  6.40k|      p->lstate = EXPR_BEG;
11988|  6.40k|    }
11989|  6.40k|    if (c == '=') {
  ------------------
  |  Branch (11989:9): [True: 6.40k, False: 0]
  ------------------
11990|  6.40k|      return tNEQ;
11991|  6.40k|    }
11992|      0|    if (c == '~') {
  ------------------
  |  Branch (11992:9): [True: 0, False: 0]
  ------------------
11993|      0|      return tNMATCH;
11994|      0|    }
11995|      0|    pushback(p, c);
11996|      0|    return '!';
11997|       |
11998|   346k|  case '=':
  ------------------
  |  Branch (11998:3): [True: 346k, False: 5.38M]
  ------------------
11999|   346k|    if (p->column == 1) {
  ------------------
  |  Branch (11999:9): [True: 0, False: 346k]
  ------------------
12000|      0|      static const char begin[] = "begin";
12001|      0|      static const char end[] = "\n=end";
12002|      0|      if (peeks(p, begin)) {
  ------------------
  |  Branch (12002:11): [True: 0, False: 0]
  ------------------
12003|      0|        c = peekc_n(p, sizeof(begin)-1);
12004|      0|        if (c < 0 || ISSPACE(c)) {
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12004:13): [True: 0, False: 0]
  ------------------
12005|      0|          do {
12006|      0|            if (!skips(p, end)) {
  ------------------
  |  Branch (12006:17): [True: 0, False: 0]
  ------------------
12007|      0|              yyerror(p, "embedded document meets end of file");
12008|      0|              return 0;
12009|      0|            }
12010|      0|            c = nextc(p);
12011|      0|          } while (!(c < 0 || ISSPACE(c)));
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12011:22): [True: 0, False: 0]
  ------------------
12012|      0|          if (c != '\n') skip(p, '\n');
  ------------------
  |  Branch (12012:15): [True: 0, False: 0]
  ------------------
12013|      0|          p->lineno+=nlines; nlines=1;
12014|      0|          p->column = 0;
12015|      0|          goto retry;
12016|      0|        }
12017|      0|      }
12018|      0|    }
12019|   346k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12019:9): [True: 0, False: 346k]
  |  Branch (12019:36): [True: 0, False: 346k]
  ------------------
12020|      0|      p->lstate = EXPR_ARG;
12021|      0|    }
12022|   346k|    else {
12023|   346k|      p->lstate = EXPR_BEG;
12024|   346k|    }
12025|   346k|    if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12025:9): [True: 2.45k, False: 343k]
  ------------------
12026|  2.45k|      if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12026:11): [True: 0, False: 2.45k]
  ------------------
12027|      0|        return tEQQ;
12028|      0|      }
12029|  2.45k|      pushback(p, c);
12030|  2.45k|      return tEQ;
12031|  2.45k|    }
12032|   343k|    if (c == '~') {
  ------------------
  |  Branch (12032:9): [True: 0, False: 343k]
  ------------------
12033|      0|      return tMATCH;
12034|      0|    }
12035|   343k|    else if (c == '>') {
  ------------------
  |  Branch (12035:14): [True: 129k, False: 214k]
  ------------------
12036|   129k|      return tASSOC;
12037|   129k|    }
12038|   214k|    pushback(p, c);
12039|   214k|    return '=';
12040|       |
12041|  5.54k|  case '<':
  ------------------
  |  Branch (12041:3): [True: 5.54k, False: 5.72M]
  ------------------
12042|  5.54k|    c = nextc(p);
12043|  5.54k|    if (c == '<' &&
  ------------------
  |  Branch (12043:9): [True: 0, False: 5.54k]
  ------------------
12044|  5.54k|        p->lstate != EXPR_DOT &&
  ------------------
  |  Branch (12044:9): [True: 0, False: 0]
  ------------------
12045|  5.54k|        p->lstate != EXPR_CLASS &&
  ------------------
  |  Branch (12045:9): [True: 0, False: 0]
  ------------------
12046|  5.54k|        !IS_END() &&
  ------------------
  |  |11138|  5.54k|#define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
  |  |  ------------------
  |  |  |  Branch (11138:19): [True: 0, False: 0]
  |  |  |  Branch (11138:44): [True: 0, False: 0]
  |  |  |  Branch (11138:72): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12047|  5.54k|        (!IS_ARG() || space_seen)) {
  ------------------
  |  |11137|      0|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  ------------------
  |  |  |  Branch (11137:19): [True: 0, False: 0]
  |  |  |  Branch (11137:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12047:23): [True: 0, False: 0]
  ------------------
12048|      0|      int token = heredoc_identifier(p);
12049|      0|      if (token)
  ------------------
  |  Branch (12049:11): [True: 0, False: 0]
  ------------------
12050|      0|        return token;
12051|      0|    }
12052|  5.54k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12052:9): [True: 0, False: 5.54k]
  |  Branch (12052:36): [True: 0, False: 5.54k]
  ------------------
12053|      0|      p->lstate = EXPR_ARG;
12054|      0|    }
12055|  5.54k|    else {
12056|  5.54k|      p->lstate = EXPR_BEG;
12057|  5.54k|      if (p->lstate == EXPR_CLASS) {
  ------------------
  |  Branch (12057:11): [True: 0, False: 5.54k]
  ------------------
12058|      0|        p->cmd_start = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
12059|      0|      }
12060|  5.54k|    }
12061|  5.54k|    if (c == '=') {
  ------------------
  |  Branch (12061:9): [True: 4.13k, False: 1.41k]
  ------------------
12062|  4.13k|      if ((c = nextc(p)) == '>') {
  ------------------
  |  Branch (12062:11): [True: 0, False: 4.13k]
  ------------------
12063|      0|        return tCMP;
12064|      0|      }
12065|  4.13k|      pushback(p, c);
12066|  4.13k|      return tLEQ;
12067|  4.13k|    }
12068|  1.41k|    if (c == '<') {
  ------------------
  |  Branch (12068:9): [True: 0, False: 1.41k]
  ------------------
12069|      0|      if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12069:11): [True: 0, False: 0]
  ------------------
12070|      0|        pylval.id = intern_op(lshift);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                      pylval.id = intern_op(lshift);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12071|      0|        p->lstate = EXPR_BEG;
12072|      0|        return tOP_ASGN;
12073|      0|      }
12074|      0|      pushback(p, c);
12075|      0|      return tLSHFT;
12076|      0|    }
12077|  1.41k|    pushback(p, c);
12078|  1.41k|    return '<';
12079|       |
12080|  17.5k|  case '>':
  ------------------
  |  Branch (12080:3): [True: 17.5k, False: 5.71M]
  ------------------
12081|  17.5k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12081:9): [True: 0, False: 17.5k]
  |  Branch (12081:36): [True: 0, False: 17.5k]
  ------------------
12082|      0|      p->lstate = EXPR_ARG;
12083|      0|    }
12084|  17.5k|    else {
12085|  17.5k|      p->lstate = EXPR_BEG;
12086|  17.5k|    }
12087|  17.5k|    if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12087:9): [True: 1.92k, False: 15.6k]
  ------------------
12088|  1.92k|      return tGEQ;
12089|  1.92k|    }
12090|  15.6k|    if (c == '>') {
  ------------------
  |  Branch (12090:9): [True: 14.0k, False: 1.51k]
  ------------------
12091|  14.0k|      if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12091:11): [True: 0, False: 14.0k]
  ------------------
12092|      0|        pylval.id = intern_op(rshift);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                      pylval.id = intern_op(rshift);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12093|      0|        p->lstate = EXPR_BEG;
12094|      0|        return tOP_ASGN;
12095|      0|      }
12096|  14.0k|      pushback(p, c);
12097|  14.0k|      return tRSHFT;
12098|  14.0k|    }
12099|  1.51k|    pushback(p, c);
12100|  1.51k|    return '>';
12101|       |
12102|   258k|  case '"':
  ------------------
  |  Branch (12102:3): [True: 258k, False: 5.46M]
  ------------------
12103|   258k|    p->lex_strterm = new_strterm(p, str_dquote, '"', 0);
12104|   258k|    return tSTRING_BEG;
12105|       |
12106|      0|  case '\'':
  ------------------
  |  Branch (12106:3): [True: 0, False: 5.72M]
  ------------------
12107|      0|    p->lex_strterm = new_strterm(p, str_squote, '\'', 0);
12108|      0|    return parse_string(p);
12109|       |
12110|      0|  case '`':
  ------------------
  |  Branch (12110:3): [True: 0, False: 5.72M]
  ------------------
12111|      0|    if (p->lstate == EXPR_FNAME) {
  ------------------
  |  Branch (12111:9): [True: 0, False: 0]
  ------------------
12112|      0|      p->lstate = EXPR_ENDFN;
12113|      0|      return '`';
12114|      0|    }
12115|      0|    if (p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12115:9): [True: 0, False: 0]
  ------------------
12116|      0|      if (cmd_state)
  ------------------
  |  Branch (12116:11): [True: 0, False: 0]
  ------------------
12117|      0|        p->lstate = EXPR_CMDARG;
12118|      0|      else
12119|      0|        p->lstate = EXPR_ARG;
12120|      0|      return '`';
12121|      0|    }
12122|      0|    p->lex_strterm = new_strterm(p, str_xquote, '`', 0);
12123|      0|    return tXSTRING_BEG;
12124|       |
12125|  8.56k|  case '?':
  ------------------
  |  Branch (12125:3): [True: 8.56k, False: 5.71M]
  ------------------
12126|  8.56k|    if (IS_END()) {
  ------------------
  |  |11138|  8.56k|#define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
  |  |  ------------------
  |  |  |  Branch (11138:19): [True: 732, False: 7.83k]
  |  |  |  Branch (11138:44): [True: 5.54k, False: 2.29k]
  |  |  |  Branch (11138:72): [True: 2.29k, False: 0]
  |  |  ------------------
  ------------------
12127|  8.56k|      p->lstate = EXPR_VALUE;
12128|  8.56k|      return '?';
12129|  8.56k|    }
12130|      0|    c = nextc(p);
12131|      0|    if (c < 0) {
  ------------------
  |  Branch (12131:9): [True: 0, False: 0]
  ------------------
12132|      0|      yyerror(p, "incomplete character syntax");
12133|      0|      return 0;
12134|      0|    }
12135|      0|    if (ISSPACE(c)) {
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12136|      0|      if (!IS_ARG()) {
  ------------------
  |  |11137|      0|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  ------------------
  |  |  |  Branch (11137:19): [True: 0, False: 0]
  |  |  |  Branch (11137:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12137|      0|        int c2;
12138|      0|        switch (c) {
12139|      0|        case ' ':
  ------------------
  |  Branch (12139:9): [True: 0, False: 0]
  ------------------
12140|      0|          c2 = 's';
12141|      0|          break;
12142|      0|        case '\n':
  ------------------
  |  Branch (12142:9): [True: 0, False: 0]
  ------------------
12143|      0|          c2 = 'n';
12144|      0|          break;
12145|      0|        case '\t':
  ------------------
  |  Branch (12145:9): [True: 0, False: 0]
  ------------------
12146|      0|          c2 = 't';
12147|      0|          break;
12148|      0|        case '\v':
  ------------------
  |  Branch (12148:9): [True: 0, False: 0]
  ------------------
12149|      0|          c2 = 'v';
12150|      0|          break;
12151|      0|        case '\r':
  ------------------
  |  Branch (12151:9): [True: 0, False: 0]
  ------------------
12152|      0|          c2 = 'r';
12153|      0|          break;
12154|      0|        case '\f':
  ------------------
  |  Branch (12154:9): [True: 0, False: 0]
  ------------------
12155|      0|          c2 = 'f';
12156|      0|          break;
12157|      0|        default:
  ------------------
  |  Branch (12157:9): [True: 0, False: 0]
  ------------------
12158|      0|          c2 = 0;
12159|      0|          break;
12160|      0|        }
12161|      0|        if (c2) {
  ------------------
  |  Branch (12161:13): [True: 0, False: 0]
  ------------------
12162|      0|          char buf[256];
12163|      0|          char cc[] = { (char)c2, '\0' };
12164|       |
12165|      0|          strcpy(buf, "invalid character syntax; use ?\\");
12166|      0|          strncat(buf, cc, 2);
12167|      0|          yyerror(p, buf);
12168|      0|        }
12169|      0|      }
12170|      0|      ternary:
12171|      0|      pushback(p, c);
12172|      0|      p->lstate = EXPR_VALUE;
12173|      0|      return '?';
12174|      0|    }
12175|      0|    newtok(p);
12176|       |    /* need support UTF-8 if configured */
12177|      0|    if ((ISALNUM(c) || c == '_')) {
  ------------------
  |  | 1344|      0|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (12177:24): [True: 0, False: 0]
  ------------------
12178|      0|      int c2 = nextc(p);
12179|      0|      pushback(p, c2);
12180|      0|      if ((ISALNUM(c2) || c2 == '_')) {
  ------------------
  |  | 1344|      0|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (12180:27): [True: 0, False: 0]
  ------------------
12181|      0|        goto ternary;
12182|      0|      }
12183|      0|    }
12184|      0|    if (c == '\\') {
  ------------------
  |  Branch (12184:9): [True: 0, False: 0]
  ------------------
12185|      0|      c = read_escape(p);
12186|      0|      tokadd(p, c);
12187|      0|    }
12188|      0|    else {
12189|      0|      tokadd(p, c);
12190|      0|    }
12191|      0|    tokfix(p);
12192|      0|    pylval.nd = new_str(p, tok(p), toklen(p));
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12193|      0|    p->lstate = EXPR_ENDARG;
12194|      0|    return tCHAR;
12195|       |
12196|      0|  case '&':
  ------------------
  |  Branch (12196:3): [True: 0, False: 5.72M]
  ------------------
12197|      0|    if ((c = nextc(p)) == '&') {
  ------------------
  |  Branch (12197:9): [True: 0, False: 0]
  ------------------
12198|      0|      p->lstate = EXPR_BEG;
12199|      0|      if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12199:11): [True: 0, False: 0]
  ------------------
12200|      0|        pylval.id = intern_op(andand);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                      pylval.id = intern_op(andand);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12201|      0|        p->lstate = EXPR_BEG;
12202|      0|        return tOP_ASGN;
12203|      0|      }
12204|      0|      pushback(p, c);
12205|      0|      return tANDOP;
12206|      0|    }
12207|      0|    else if (c == '.') {
  ------------------
  |  Branch (12207:14): [True: 0, False: 0]
  ------------------
12208|      0|      p->lstate = EXPR_DOT;
12209|      0|      return tANDDOT;
12210|      0|    }
12211|      0|    else if (c == '=') {
  ------------------
  |  Branch (12211:14): [True: 0, False: 0]
  ------------------
12212|      0|      pylval.id = intern_op(and);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(and);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12213|      0|      p->lstate = EXPR_BEG;
12214|      0|      return tOP_ASGN;
12215|      0|    }
12216|      0|    pushback(p, c);
12217|      0|    if (IS_SPCARG(c)) {
  ------------------
  |  |11140|      0|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|      0|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 0]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12218|      0|      yywarning(p, "'&' interpreted as argument prefix");
12219|      0|      c = tAMPER;
12220|      0|    }
12221|      0|    else if (IS_BEG()) {
  ------------------
  |  |11139|      0|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 0]
  |  |  |  Branch (11139:44): [True: 0, False: 0]
  |  |  |  Branch (11139:69): [True: 0, False: 0]
  |  |  |  Branch (11139:96): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12222|      0|      c = tAMPER;
12223|      0|    }
12224|      0|    else {
12225|      0|      c = '&';
12226|      0|    }
12227|      0|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12227:9): [True: 0, False: 0]
  |  Branch (12227:36): [True: 0, False: 0]
  ------------------
12228|      0|      p->lstate = EXPR_ARG;
12229|      0|    }
12230|      0|    else {
12231|      0|      p->lstate = EXPR_BEG;
12232|      0|    }
12233|      0|    return c;
12234|       |
12235|  31.8k|  case '|':
  ------------------
  |  Branch (12235:3): [True: 31.8k, False: 5.69M]
  ------------------
12236|  31.8k|    if ((c = nextc(p)) == '|') {
  ------------------
  |  Branch (12236:9): [True: 31.8k, False: 0]
  ------------------
12237|  31.8k|      p->lstate = EXPR_BEG;
12238|  31.8k|      if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12238:11): [True: 31.8k, False: 0]
  ------------------
12239|  31.8k|        pylval.id = intern_op(oror);
  ------------------
  |  |10739|  31.8k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                      pylval.id = intern_op(oror);
  ------------------
  |  |  155|  31.8k|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|  31.8k|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12240|  31.8k|        p->lstate = EXPR_BEG;
12241|  31.8k|        return tOP_ASGN;
12242|  31.8k|      }
12243|      0|      pushback(p, c);
12244|      0|      return tOROP;
12245|  31.8k|    }
12246|      0|    if (c == '=') {
  ------------------
  |  Branch (12246:9): [True: 0, False: 0]
  ------------------
12247|      0|      pylval.id = intern_op(or);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(or);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12248|      0|      p->lstate = EXPR_BEG;
12249|      0|      return tOP_ASGN;
12250|      0|    }
12251|      0|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12251:9): [True: 0, False: 0]
  |  Branch (12251:36): [True: 0, False: 0]
  ------------------
12252|      0|      p->lstate = EXPR_ARG;
12253|      0|    }
12254|      0|    else {
12255|      0|      p->lstate = EXPR_BEG;
12256|      0|    }
12257|      0|    pushback(p, c);
12258|      0|    return '|';
12259|       |
12260|  19.7k|  case '+':
  ------------------
  |  Branch (12260:3): [True: 19.7k, False: 5.70M]
  ------------------
12261|  19.7k|    c = nextc(p);
12262|  19.7k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12262:9): [True: 0, False: 19.7k]
  |  Branch (12262:36): [True: 0, False: 19.7k]
  ------------------
12263|      0|      p->lstate = EXPR_ARG;
12264|      0|      if (c == '@') {
  ------------------
  |  Branch (12264:11): [True: 0, False: 0]
  ------------------
12265|      0|        return tUPLUS;
12266|      0|      }
12267|      0|      pushback(p, c);
12268|      0|      return '+';
12269|      0|    }
12270|  19.7k|    if (c == '=') {
  ------------------
  |  Branch (12270:9): [True: 0, False: 19.7k]
  ------------------
12271|      0|      pylval.id = intern_op(add);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(add);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12272|      0|      p->lstate = EXPR_BEG;
12273|      0|      return tOP_ASGN;
12274|      0|    }
12275|  19.7k|    if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
  ------------------
  |  |11139|  39.5k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 19.7k]
  |  |  |  Branch (11139:44): [True: 0, False: 19.7k]
  |  |  |  Branch (11139:69): [True: 0, False: 19.7k]
  |  |  |  Branch (11139:96): [True: 0, False: 19.7k]
  |  |  ------------------
  ------------------
                  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
  ------------------
  |  |11140|  39.5k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|  39.5k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 19.7k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 19.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12275:38): [True: 0, False: 0]
  ------------------
12276|      0|      p->lstate = EXPR_BEG;
12277|      0|      pushback(p, c);
12278|      0|      if (c >= 0 && ISDIGIT(c)) {
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12278:11): [True: 0, False: 0]
  ------------------
12279|      0|        c = '+';
12280|      0|        goto start_num;
12281|      0|      }
12282|      0|      return tUPLUS;
12283|      0|    }
12284|  19.7k|    p->lstate = EXPR_BEG;
12285|  19.7k|    pushback(p, c);
12286|  19.7k|    return '+';
12287|       |
12288|  21.9k|  case '-':
  ------------------
  |  Branch (12288:3): [True: 21.9k, False: 5.70M]
  ------------------
12289|  21.9k|    c = nextc(p);
12290|  21.9k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12290:9): [True: 0, False: 21.9k]
  |  Branch (12290:36): [True: 0, False: 21.9k]
  ------------------
12291|      0|      p->lstate = EXPR_ARG;
12292|      0|      if (c == '@') {
  ------------------
  |  Branch (12292:11): [True: 0, False: 0]
  ------------------
12293|      0|        return tUMINUS;
12294|      0|      }
12295|      0|      pushback(p, c);
12296|      0|      return '-';
12297|      0|    }
12298|  21.9k|    if (c == '=') {
  ------------------
  |  Branch (12298:9): [True: 0, False: 21.9k]
  ------------------
12299|      0|      pylval.id = intern_op(sub);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(sub);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12300|      0|      p->lstate = EXPR_BEG;
12301|      0|      return tOP_ASGN;
12302|      0|    }
12303|  21.9k|    if (c == '>') {
  ------------------
  |  Branch (12303:9): [True: 0, False: 21.9k]
  ------------------
12304|      0|      p->lstate = EXPR_ENDFN;
12305|      0|      return tLAMBDA;
12306|      0|    }
12307|  21.9k|    if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
  ------------------
  |  |11139|  43.8k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 21.9k]
  |  |  |  Branch (11139:44): [True: 0, False: 21.9k]
  |  |  |  Branch (11139:69): [True: 0, False: 21.9k]
  |  |  |  Branch (11139:96): [True: 0, False: 21.9k]
  |  |  ------------------
  ------------------
                  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
  ------------------
  |  |11140|  43.8k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|  43.8k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 21.9k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 21.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12307:38): [True: 0, False: 0]
  ------------------
12308|      0|      p->lstate = EXPR_BEG;
12309|      0|      pushback(p, c);
12310|      0|      if (c >= 0 && ISDIGIT(c)) {
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12310:11): [True: 0, False: 0]
  ------------------
12311|      0|        return tUMINUS_NUM;
12312|      0|      }
12313|      0|      return tUMINUS;
12314|      0|    }
12315|  21.9k|    p->lstate = EXPR_BEG;
12316|  21.9k|    pushback(p, c);
12317|  21.9k|    return '-';
12318|       |
12319|  95.8k|  case '.':
  ------------------
  |  Branch (12319:3): [True: 95.8k, False: 5.63M]
  ------------------
12320|  95.8k|    {
12321|  95.8k|      int is_beg = IS_BEG();
  ------------------
  |  |11139|  95.8k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 95.8k]
  |  |  |  Branch (11139:44): [True: 0, False: 95.8k]
  |  |  |  Branch (11139:69): [True: 0, False: 95.8k]
  |  |  |  Branch (11139:96): [True: 0, False: 95.8k]
  |  |  ------------------
  ------------------
12322|  95.8k|      p->lstate = EXPR_MID;
12323|  95.8k|      if ((c = nextc(p)) == '.') {
  ------------------
  |  Branch (12323:11): [True: 0, False: 95.8k]
  ------------------
12324|      0|        if ((c = nextc(p)) == '.') {
  ------------------
  |  Branch (12324:13): [True: 0, False: 0]
  ------------------
12325|      0|          return is_beg ? tBDOT3 : tDOT3;
  ------------------
  |  Branch (12325:18): [True: 0, False: 0]
  ------------------
12326|      0|        }
12327|      0|        pushback(p, c);
12328|      0|        return is_beg ? tBDOT2 : tDOT2;
  ------------------
  |  Branch (12328:16): [True: 0, False: 0]
  ------------------
12329|      0|      }
12330|  95.8k|      pushback(p, c);
12331|  95.8k|      p->lstate = EXPR_BEG;
12332|  95.8k|      if (c >= 0 && ISDIGIT(c)) {
  ------------------
  |  | 1342|  95.8k|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 95.8k]
  |  |  ------------------
  ------------------
  |  Branch (12332:11): [True: 95.8k, False: 0]
  ------------------
12333|      0|        yyerror(p, "no .<digit> floating literal anymore; put 0 before dot");
12334|      0|      }
12335|  95.8k|      p->lstate = EXPR_DOT;
12336|  95.8k|      return '.';
12337|  95.8k|    }
12338|       |
12339|      0|    start_num:
12340|   681k|  case '0': case '1': case '2': case '3': case '4':
  ------------------
  |  Branch (12340:3): [True: 10.2k, False: 5.71M]
  |  Branch (12340:13): [True: 666k, False: 5.06M]
  |  Branch (12340:23): [True: 1.40k, False: 5.72M]
  |  Branch (12340:33): [True: 1.59k, False: 5.72M]
  |  Branch (12340:43): [True: 2.38k, False: 5.72M]
  ------------------
12341|   705k|  case '5': case '6': case '7': case '8': case '9':
  ------------------
  |  Branch (12341:3): [True: 1.91k, False: 5.72M]
  |  Branch (12341:13): [True: 7.94k, False: 5.71M]
  |  Branch (12341:23): [True: 1.80k, False: 5.72M]
  |  Branch (12341:33): [True: 9.89k, False: 5.71M]
  |  Branch (12341:43): [True: 1.71k, False: 5.72M]
  ------------------
12342|   705k|  {
12343|   705k|    int is_float, seen_point, seen_e, nondigit;
12344|   705k|    int suffix = 0;
12345|       |
12346|   705k|    is_float = seen_point = seen_e = nondigit = 0;
12347|   705k|    p->lstate = EXPR_ENDARG;
12348|   705k|    newtok(p);
12349|   705k|    if (c == '-' || c == '+') {
  ------------------
  |  Branch (12349:9): [True: 0, False: 705k]
  |  Branch (12349:21): [True: 0, False: 705k]
  ------------------
12350|      0|      tokadd(p, c);
12351|      0|      c = nextc(p);
12352|      0|    }
12353|   705k|    if (c == '0') {
  ------------------
  |  Branch (12353:9): [True: 10.2k, False: 694k]
  ------------------
12354|  10.2k|#define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
12355|  10.2k|      int start = toklen(p);
12356|  10.2k|      c = nextc(p);
12357|  10.2k|      if (c == 'x' || c == 'X') {
  ------------------
  |  Branch (12357:11): [True: 0, False: 10.2k]
  |  Branch (12357:23): [True: 0, False: 10.2k]
  ------------------
12358|       |        /* hexadecimal */
12359|      0|        c = nextc(p);
12360|      0|        if (c >= 0 && ISXDIGIT(c)) {
  ------------------
  |  | 1343|      0|#define ISXDIGIT(c) (ISDIGIT(c) || ((unsigned)(c) | 0x20) - 'a' < 6)
  |  |  ------------------
  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1343:36): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12360:13): [True: 0, False: 0]
  ------------------
12361|      0|          do {
12362|      0|            if (c == '_') {
  ------------------
  |  Branch (12362:17): [True: 0, False: 0]
  ------------------
12363|      0|              if (nondigit) break;
  ------------------
  |  Branch (12363:19): [True: 0, False: 0]
  ------------------
12364|      0|              nondigit = c;
12365|      0|              continue;
12366|      0|            }
12367|      0|            if (!ISXDIGIT(c)) break;
  ------------------
  |  | 1343|      0|#define ISXDIGIT(c) (ISDIGIT(c) || ((unsigned)(c) | 0x20) - 'a' < 6)
  |  |  ------------------
  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1343:36): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12368|      0|            nondigit = 0;
12369|      0|            tokadd(p, tolower(c));
12370|      0|          } while ((c = nextc(p)) >= 0);
  ------------------
  |  Branch (12370:20): [True: 0, False: 0]
  ------------------
12371|      0|        }
12372|      0|        pushback(p, c);
12373|      0|        tokfix(p);
12374|      0|        if (toklen(p) == start) {
  ------------------
  |  Branch (12374:13): [True: 0, False: 0]
  ------------------
12375|      0|          no_digits();
  ------------------
  |  |12354|      0|#define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
  |  |  ------------------
  |  |  |  Branch (12354:88): [Folded - Ignored]
  |  |  ------------------
  ------------------
12376|      0|        }
12377|      0|        else if (nondigit) goto trailing_uc;
  ------------------
  |  Branch (12377:18): [True: 0, False: 0]
  ------------------
12378|      0|        suffix = number_literal_suffix(p);
12379|      0|        pylval.nd = new_int(p, tok(p), 16, suffix);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12380|      0|        return tINTEGER;
12381|      0|      }
12382|  10.2k|      if (c == 'b' || c == 'B') {
  ------------------
  |  Branch (12382:11): [True: 0, False: 10.2k]
  |  Branch (12382:23): [True: 0, False: 10.2k]
  ------------------
12383|       |        /* binary */
12384|      0|        c = nextc(p);
12385|      0|        if (c == '0' || c == '1') {
  ------------------
  |  Branch (12385:13): [True: 0, False: 0]
  |  Branch (12385:25): [True: 0, False: 0]
  ------------------
12386|      0|          do {
12387|      0|            if (c == '_') {
  ------------------
  |  Branch (12387:17): [True: 0, False: 0]
  ------------------
12388|      0|              if (nondigit) break;
  ------------------
  |  Branch (12388:19): [True: 0, False: 0]
  ------------------
12389|      0|              nondigit = c;
12390|      0|              continue;
12391|      0|            }
12392|      0|            if (c != '0' && c != '1') break;
  ------------------
  |  Branch (12392:17): [True: 0, False: 0]
  |  Branch (12392:29): [True: 0, False: 0]
  ------------------
12393|      0|            nondigit = 0;
12394|      0|            tokadd(p, c);
12395|      0|          } while ((c = nextc(p)) >= 0);
  ------------------
  |  Branch (12395:20): [True: 0, False: 0]
  ------------------
12396|      0|        }
12397|      0|        pushback(p, c);
12398|      0|        tokfix(p);
12399|      0|        if (toklen(p) == start) {
  ------------------
  |  Branch (12399:13): [True: 0, False: 0]
  ------------------
12400|      0|          no_digits();
  ------------------
  |  |12354|      0|#define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
  |  |  ------------------
  |  |  |  Branch (12354:88): [Folded - Ignored]
  |  |  ------------------
  ------------------
12401|      0|        }
12402|      0|        else if (nondigit) goto trailing_uc;
  ------------------
  |  Branch (12402:18): [True: 0, False: 0]
  ------------------
12403|      0|        suffix = number_literal_suffix(p);
12404|      0|        pylval.nd = new_int(p, tok(p), 2, suffix);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12405|      0|        return tINTEGER;
12406|      0|      }
12407|  10.2k|      if (c == 'd' || c == 'D') {
  ------------------
  |  Branch (12407:11): [True: 0, False: 10.2k]
  |  Branch (12407:23): [True: 0, False: 10.2k]
  ------------------
12408|       |        /* decimal */
12409|      0|        c = nextc(p);
12410|      0|        if (c >= 0 && ISDIGIT(c)) {
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12410:13): [True: 0, False: 0]
  ------------------
12411|      0|          do {
12412|      0|            if (c == '_') {
  ------------------
  |  Branch (12412:17): [True: 0, False: 0]
  ------------------
12413|      0|              if (nondigit) break;
  ------------------
  |  Branch (12413:19): [True: 0, False: 0]
  ------------------
12414|      0|              nondigit = c;
12415|      0|              continue;
12416|      0|            }
12417|      0|            if (!ISDIGIT(c)) break;
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  ------------------
  |  Branch (12417:17): [True: 0, False: 0]
  ------------------
12418|      0|            nondigit = 0;
12419|      0|            tokadd(p, c);
12420|      0|          } while ((c = nextc(p)) >= 0);
  ------------------
  |  Branch (12420:20): [True: 0, False: 0]
  ------------------
12421|      0|        }
12422|      0|        pushback(p, c);
12423|      0|        tokfix(p);
12424|      0|        if (toklen(p) == start) {
  ------------------
  |  Branch (12424:13): [True: 0, False: 0]
  ------------------
12425|      0|          no_digits();
  ------------------
  |  |12354|      0|#define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
  |  |  ------------------
  |  |  |  Branch (12354:88): [Folded - Ignored]
  |  |  ------------------
  ------------------
12426|      0|        }
12427|      0|        else if (nondigit) goto trailing_uc;
  ------------------
  |  Branch (12427:18): [True: 0, False: 0]
  ------------------
12428|      0|        suffix = number_literal_suffix(p);
12429|      0|        pylval.nd = new_int(p, tok(p), 10, suffix);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12430|      0|        return tINTEGER;
12431|      0|      }
12432|  10.2k|      if (c == '_') {
  ------------------
  |  Branch (12432:11): [True: 0, False: 10.2k]
  ------------------
12433|       |        /* 0_0 */
12434|      0|        goto octal_number;
12435|      0|      }
12436|  10.2k|      if (c == 'o' || c == 'O') {
  ------------------
  |  Branch (12436:11): [True: 0, False: 10.2k]
  |  Branch (12436:23): [True: 0, False: 10.2k]
  ------------------
12437|       |        /* prefixed octal */
12438|      0|        c = nextc(p);
12439|      0|        if (c < 0 || c == '_' || !ISDIGIT(c)) {
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  ------------------
  |  Branch (12439:13): [True: 0, False: 0]
  |  Branch (12439:22): [True: 0, False: 0]
  |  Branch (12439:34): [True: 0, False: 0]
  ------------------
12440|      0|          no_digits();
  ------------------
  |  |12354|      0|#define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
  |  |  ------------------
  |  |  |  Branch (12354:88): [Folded - Ignored]
  |  |  ------------------
  ------------------
12441|      0|        }
12442|      0|      }
12443|  10.2k|      if (c >= '0' && c <= '7') {
  ------------------
  |  Branch (12443:11): [True: 0, False: 10.2k]
  |  Branch (12443:23): [True: 0, False: 0]
  ------------------
12444|       |        /* octal */
12445|      0|        octal_number:
12446|      0|        do {
12447|      0|          if (c == '_') {
  ------------------
  |  Branch (12447:15): [True: 0, False: 0]
  ------------------
12448|      0|            if (nondigit) break;
  ------------------
  |  Branch (12448:17): [True: 0, False: 0]
  ------------------
12449|      0|            nondigit = c;
12450|      0|            continue;
12451|      0|          }
12452|      0|          if (c < '0' || c > '9') break;
  ------------------
  |  Branch (12452:15): [True: 0, False: 0]
  |  Branch (12452:26): [True: 0, False: 0]
  ------------------
12453|      0|          if (c > '7') goto invalid_octal;
  ------------------
  |  Branch (12453:15): [True: 0, False: 0]
  ------------------
12454|      0|          nondigit = 0;
12455|      0|          tokadd(p, c);
12456|      0|        } while ((c = nextc(p)) >= 0);
  ------------------
  |  Branch (12456:18): [True: 0, False: 0]
  ------------------
12457|       |
12458|      0|        if (toklen(p) > start) {
  ------------------
  |  Branch (12458:13): [True: 0, False: 0]
  ------------------
12459|      0|          pushback(p, c);
12460|      0|          tokfix(p);
12461|      0|          if (nondigit) goto trailing_uc;
  ------------------
  |  Branch (12461:15): [True: 0, False: 0]
  ------------------
12462|      0|          suffix = number_literal_suffix(p);
12463|      0|          pylval.nd = new_int(p, tok(p), 8, suffix);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12464|      0|          return tINTEGER;
12465|      0|        }
12466|      0|        if (nondigit) {
  ------------------
  |  Branch (12466:13): [True: 0, False: 0]
  ------------------
12467|      0|          pushback(p, c);
12468|      0|          goto trailing_uc;
12469|      0|        }
12470|      0|      }
12471|  10.2k|      if (c > '7' && c <= '9') {
  ------------------
  |  Branch (12471:11): [True: 0, False: 10.2k]
  |  Branch (12471:22): [True: 0, False: 0]
  ------------------
12472|      0|        invalid_octal:
12473|      0|        yyerror(p, "Invalid octal digit");
12474|      0|      }
12475|  10.2k|      else if (c == '.' || c == 'e' || c == 'E') {
  ------------------
  |  Branch (12475:16): [True: 0, False: 10.2k]
  |  Branch (12475:28): [True: 0, False: 10.2k]
  |  Branch (12475:40): [True: 0, False: 10.2k]
  ------------------
12476|      0|        tokadd(p, '0');
12477|      0|      }
12478|  10.2k|      else {
12479|  10.2k|        pushback(p, c);
12480|  10.2k|        suffix = number_literal_suffix(p);
12481|  10.2k|        pylval.nd = new_int(p, "0", 10, suffix);
  ------------------
  |  |10739|  10.2k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12482|  10.2k|        return tINTEGER;
12483|  10.2k|      }
12484|  10.2k|    }
12485|       |
12486|  1.39M|    for (;;) {
12487|  1.39M|      switch (c) {
12488|   675k|      case '0': case '1': case '2': case '3': case '4':
  ------------------
  |  Branch (12488:7): [True: 1.74k, False: 1.39M]
  |  Branch (12488:17): [True: 667k, False: 726k]
  |  Branch (12488:27): [True: 2.95k, False: 1.39M]
  |  Branch (12488:37): [True: 1.59k, False: 1.39M]
  |  Branch (12488:47): [True: 2.38k, False: 1.39M]
  ------------------
12489|   698k|      case '5': case '6': case '7': case '8': case '9':
  ------------------
  |  Branch (12489:7): [True: 1.91k, False: 1.39M]
  |  Branch (12489:17): [True: 7.94k, False: 1.38M]
  |  Branch (12489:27): [True: 1.80k, False: 1.39M]
  |  Branch (12489:37): [True: 9.89k, False: 1.38M]
  |  Branch (12489:47): [True: 1.71k, False: 1.39M]
  ------------------
12490|   698k|        nondigit = 0;
12491|   698k|        tokadd(p, c);
12492|   698k|        break;
12493|       |
12494|      0|      case '.':
  ------------------
  |  Branch (12494:7): [True: 0, False: 1.39M]
  ------------------
12495|      0|        if (nondigit) goto trailing_uc;
  ------------------
  |  Branch (12495:13): [True: 0, False: 0]
  ------------------
12496|      0|        if (seen_point || seen_e) {
  ------------------
  |  Branch (12496:13): [True: 0, False: 0]
  |  Branch (12496:27): [True: 0, False: 0]
  ------------------
12497|      0|          goto decode_num;
12498|      0|        }
12499|      0|        else {
12500|      0|          int c0 = nextc(p);
12501|      0|          if (c0 < 0 || !ISDIGIT(c0)) {
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  ------------------
  |  Branch (12501:15): [True: 0, False: 0]
  |  Branch (12501:25): [True: 0, False: 0]
  ------------------
12502|      0|            pushback(p, c0);
12503|      0|            goto decode_num;
12504|      0|          }
12505|      0|          c = c0;
12506|      0|        }
12507|      0|        tokadd(p, '.');
12508|      0|        tokadd(p, c);
12509|      0|        is_float++;
12510|      0|        seen_point++;
12511|      0|        nondigit = 0;
12512|      0|        break;
12513|       |
12514|      0|      case 'e':
  ------------------
  |  Branch (12514:7): [True: 0, False: 1.39M]
  ------------------
12515|      0|      case 'E':
  ------------------
  |  Branch (12515:7): [True: 0, False: 1.39M]
  ------------------
12516|      0|        if (nondigit) {
  ------------------
  |  Branch (12516:13): [True: 0, False: 0]
  ------------------
12517|      0|          pushback(p, c);
12518|      0|          c = nondigit;
12519|      0|          goto decode_num;
12520|      0|        }
12521|      0|        if (seen_e) {
  ------------------
  |  Branch (12521:13): [True: 0, False: 0]
  ------------------
12522|      0|          goto decode_num;
12523|      0|        }
12524|      0|        tokadd(p, c);
12525|      0|        seen_e++;
12526|      0|        is_float++;
12527|      0|        nondigit = c;
12528|      0|        c = nextc(p);
12529|      0|        if (c != '-' && c != '+') continue;
  ------------------
  |  Branch (12529:13): [True: 0, False: 0]
  |  Branch (12529:25): [True: 0, False: 0]
  ------------------
12530|      0|        tokadd(p, c);
12531|      0|        nondigit = c;
12532|      0|        break;
12533|       |
12534|      0|      case '_':       /* '_' in number just ignored */
  ------------------
  |  Branch (12534:7): [True: 0, False: 1.39M]
  ------------------
12535|      0|        if (nondigit) goto decode_num;
  ------------------
  |  Branch (12535:13): [True: 0, False: 0]
  ------------------
12536|      0|        nondigit = c;
12537|      0|        break;
12538|       |
12539|   694k|      default:
  ------------------
  |  Branch (12539:7): [True: 694k, False: 698k]
  ------------------
12540|   694k|        goto decode_num;
12541|  1.39M|      }
12542|   698k|      c = nextc(p);
12543|   698k|    }
12544|       |
12545|   694k|    decode_num:
12546|   694k|    pushback(p, c);
12547|   694k|    if (nondigit) {
  ------------------
  |  Branch (12547:9): [True: 0, False: 694k]
  ------------------
12548|      0|      trailing_uc:
12549|      0|      yyerror_c(p, "trailing non digit in number: ", (char)nondigit);
12550|      0|    }
12551|   694k|    tokfix(p);
12552|   694k|    if (is_float) {
  ------------------
  |  Branch (12552:9): [True: 0, False: 694k]
  ------------------
12553|       |#ifdef MRB_NO_FLOAT
12554|       |      yywarning_s(p, "floating-point numbers are not supported", tok(p));
12555|       |      pylval.nd = new_int(p, "0", 10, 0);
12556|       |      return tINTEGER;
12557|       |#else
12558|      0|      double d;
12559|       |
12560|      0|      if (!mrb_read_float(tok(p), NULL, &d)) {
  ------------------
  |  Branch (12560:11): [True: 0, False: 0]
  ------------------
12561|      0|        yywarning_s(p, "corrupted float value", tok(p));
12562|      0|      }
12563|      0|      suffix = number_literal_suffix(p);
12564|      0|      if (seen_e && (suffix & NUM_SUFFIX_R)) {
  ------------------
  |  |  138|      0|#define NUM_SUFFIX_R   (1<<0)
  ------------------
  |  Branch (12564:11): [True: 0, False: 0]
  |  Branch (12564:21): [True: 0, False: 0]
  ------------------
12565|      0|        pushback(p, 'r');
12566|      0|        suffix &= ~NUM_SUFFIX_R;
  ------------------
  |  |  138|      0|#define NUM_SUFFIX_R   (1<<0)
  ------------------
12567|      0|      }
12568|      0|      pylval.nd = new_float(p, tok(p), suffix);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12569|      0|      return tFLOAT;
12570|      0|#endif
12571|      0|    }
12572|   694k|    suffix = number_literal_suffix(p);
12573|   694k|    pylval.nd = new_int(p, tok(p), 10, suffix);
  ------------------
  |  |10739|   694k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12574|   694k|    return tINTEGER;
12575|   694k|  }
12576|       |
12577|   280k|  case ')':
  ------------------
  |  Branch (12577:3): [True: 280k, False: 5.44M]
  ------------------
12578|   336k|  case ']':
  ------------------
  |  Branch (12578:3): [True: 55.7k, False: 5.67M]
  ------------------
12579|   336k|    p->paren_nest--;
12580|       |    /* fall through */
12581|   340k|  case '}':
  ------------------
  |  Branch (12581:3): [True: 3.61k, False: 5.72M]
  ------------------
12582|   340k|    COND_LEXPOP();
  ------------------
  |  |  116|   340k|#define COND_LEXPOP()   BITSTACK_LEXPOP(p->cond_stack)
  |  |  ------------------
  |  |  |  |  111|   340k|#define BITSTACK_LEXPOP(stack)  ((stack) = ((stack) >> 1) | ((stack) & 1))
  |  |  ------------------
  ------------------
12583|   340k|    CMDARG_LEXPOP();
  ------------------
  |  |  121|   340k|#define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack)
  |  |  ------------------
  |  |  |  |  111|   340k|#define BITSTACK_LEXPOP(stack)  ((stack) = ((stack) >> 1) | ((stack) & 1))
  |  |  ------------------
  ------------------
12584|   340k|    if (c == ')')
  ------------------
  |  Branch (12584:9): [True: 280k, False: 59.3k]
  ------------------
12585|   280k|      p->lstate = EXPR_ENDFN;
12586|  59.3k|    else
12587|  59.3k|      p->lstate = EXPR_END;
12588|   340k|    return c;
12589|       |
12590|  11.6k|  case ':':
  ------------------
  |  Branch (12590:3): [True: 11.6k, False: 5.71M]
  ------------------
12591|  11.6k|    c = nextc(p);
12592|  11.6k|    if (c == ':') {
  ------------------
  |  Branch (12592:9): [True: 3.08k, False: 8.56k]
  ------------------
12593|  3.08k|      if (IS_BEG() || p->lstate == EXPR_CLASS || IS_SPCARG(-1)) {
  ------------------
  |  |11139|  6.16k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 3.08k]
  |  |  |  Branch (11139:44): [True: 0, False: 3.08k]
  |  |  |  Branch (11139:69): [True: 0, False: 3.08k]
  |  |  |  Branch (11139:96): [True: 0, False: 3.08k]
  |  |  ------------------
  ------------------
                    if (IS_BEG() || p->lstate == EXPR_CLASS || IS_SPCARG(-1)) {
  ------------------
  |  |11140|  3.08k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|  6.16k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 3.08k, False: 0]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [Folded - Ignored]
  |  |  |  |  |  Branch (1338:35): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 3.08k]
  |  |  ------------------
  ------------------
  |  Branch (12593:23): [True: 0, False: 3.08k]
  ------------------
12594|      0|        p->lstate = EXPR_BEG;
12595|      0|        return tCOLON3;
12596|      0|      }
12597|  3.08k|      p->lstate = EXPR_DOT;
12598|  3.08k|      return tCOLON2;
12599|  3.08k|    }
12600|  8.56k|    if (!space_seen && IS_END()) {
  ------------------
  |  |11138|      0|#define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
  |  |  ------------------
  |  |  |  Branch (11138:19): [True: 0, False: 0]
  |  |  |  Branch (11138:44): [True: 0, False: 0]
  |  |  |  Branch (11138:72): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12600:9): [True: 0, False: 8.56k]
  ------------------
12601|      0|      pushback(p, c);
12602|      0|      p->lstate = EXPR_BEG;
12603|      0|      return tLABEL_TAG;
12604|      0|    }
12605|  8.56k|    if (IS_END() || ISSPACE(c) || c == '#') {
  ------------------
  |  |11138|  17.1k|#define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
  |  |  ------------------
  |  |  |  Branch (11138:19): [True: 1.42k, False: 7.13k]
  |  |  |  Branch (11138:44): [True: 5.19k, False: 1.94k]
  |  |  |  Branch (11138:72): [True: 1.94k, False: 0]
  |  |  ------------------
  ------------------
                  if (IS_END() || ISSPACE(c) || c == '#') {
  ------------------
  |  | 1338|  8.56k|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12605:35): [True: 0, False: 0]
  ------------------
12606|  8.56k|      pushback(p, c);
12607|  8.56k|      p->lstate = EXPR_BEG;
12608|  8.56k|      return ':';
12609|  8.56k|    }
12610|      0|    pushback(p, c);
12611|      0|    p->lstate = EXPR_FNAME;
12612|      0|    return tSYMBEG;
12613|       |
12614|  12.8k|  case '/':
  ------------------
  |  Branch (12614:3): [True: 12.8k, False: 5.71M]
  ------------------
12615|  12.8k|    if (IS_BEG()) {
  ------------------
  |  |11139|  12.8k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 12.8k]
  |  |  |  Branch (11139:44): [True: 0, False: 12.8k]
  |  |  |  Branch (11139:69): [True: 0, False: 12.8k]
  |  |  |  Branch (11139:96): [True: 0, False: 12.8k]
  |  |  ------------------
  ------------------
12616|      0|      p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
12617|      0|      return tREGEXP_BEG;
12618|      0|    }
12619|  12.8k|    if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12619:9): [True: 0, False: 12.8k]
  ------------------
12620|      0|      pylval.id = intern_op(div);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(div);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12621|      0|      p->lstate = EXPR_BEG;
12622|      0|      return tOP_ASGN;
12623|      0|    }
12624|  12.8k|    pushback(p, c);
12625|  12.8k|    if (IS_SPCARG(c)) {
  ------------------
  |  |11140|  12.8k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|  25.6k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 12.8k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 12.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12626|      0|      p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
12627|      0|      return tREGEXP_BEG;
12628|      0|    }
12629|  12.8k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12629:9): [True: 0, False: 12.8k]
  |  Branch (12629:36): [True: 0, False: 12.8k]
  ------------------
12630|      0|      p->lstate = EXPR_ARG;
12631|      0|    }
12632|  12.8k|    else {
12633|  12.8k|      p->lstate = EXPR_BEG;
12634|  12.8k|    }
12635|  12.8k|    return '/';
12636|       |
12637|  9.95k|  case '^':
  ------------------
  |  Branch (12637:3): [True: 9.95k, False: 5.71M]
  ------------------
12638|  9.95k|    if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12638:9): [True: 0, False: 9.95k]
  ------------------
12639|      0|      pylval.id = intern_op(xor);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(xor);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12640|      0|      p->lstate = EXPR_BEG;
12641|      0|      return tOP_ASGN;
12642|      0|    }
12643|  9.95k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12643:9): [True: 0, False: 9.95k]
  |  Branch (12643:36): [True: 0, False: 9.95k]
  ------------------
12644|      0|      p->lstate = EXPR_ARG;
12645|      0|    }
12646|  9.95k|    else {
12647|  9.95k|      p->lstate = EXPR_BEG;
12648|  9.95k|    }
12649|  9.95k|    pushback(p, c);
12650|  9.95k|    return '^';
12651|       |
12652|      0|  case ';':
  ------------------
  |  Branch (12652:3): [True: 0, False: 5.72M]
  ------------------
12653|      0|    p->lstate = EXPR_BEG;
12654|      0|    return ';';
12655|       |
12656|   364k|  case ',':
  ------------------
  |  Branch (12656:3): [True: 364k, False: 5.36M]
  ------------------
12657|   364k|    p->lstate = EXPR_BEG;
12658|   364k|    return ',';
12659|       |
12660|      0|  case '~':
  ------------------
  |  Branch (12660:3): [True: 0, False: 5.72M]
  ------------------
12661|      0|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12661:9): [True: 0, False: 0]
  |  Branch (12661:36): [True: 0, False: 0]
  ------------------
12662|      0|      if ((c = nextc(p)) != '@') {
  ------------------
  |  Branch (12662:11): [True: 0, False: 0]
  ------------------
12663|      0|        pushback(p, c);
12664|      0|      }
12665|      0|      p->lstate = EXPR_ARG;
12666|      0|    }
12667|      0|    else {
12668|      0|      p->lstate = EXPR_BEG;
12669|      0|    }
12670|      0|    return '~';
12671|       |
12672|   280k|  case '(':
  ------------------
  |  Branch (12672:3): [True: 280k, False: 5.44M]
  ------------------
12673|   280k|    if (IS_BEG()) {
  ------------------
  |  |11139|   280k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 170k, False: 110k]
  |  |  |  Branch (11139:44): [True: 0, False: 110k]
  |  |  |  Branch (11139:69): [True: 12.8k, False: 97.5k]
  |  |  |  Branch (11139:96): [True: 0, False: 97.5k]
  |  |  ------------------
  ------------------
12674|   183k|      c = tLPAREN;
12675|   183k|    }
12676|  97.5k|    else if (IS_SPCARG(-1)) {
  ------------------
  |  |11140|  97.5k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|   195k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 95.8k, False: 1.74k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 1.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [Folded - Ignored]
  |  |  |  |  |  Branch (1338:35): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 95.8k]
  |  |  ------------------
  ------------------
12677|      0|      c = tLPAREN_ARG;
12678|      0|    }
12679|  97.5k|    else if (p->lstate == EXPR_END && space_seen) {
  ------------------
  |  Branch (12679:14): [True: 0, False: 97.5k]
  |  Branch (12679:39): [True: 0, False: 0]
  ------------------
12680|      0|      c = tLPAREN_ARG;
12681|      0|    }
12682|   280k|    p->paren_nest++;
12683|   280k|    COND_PUSH(0);
  ------------------
  |  |  114|   280k|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|   280k|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12684|   280k|    CMDARG_PUSH(0);
  ------------------
  |  |  119|   280k|#define CMDARG_PUSH(n)  BITSTACK_PUSH(p->cmdarg_stack, (n))
  |  |  ------------------
  |  |  |  |  109|   280k|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12685|   280k|    p->lstate = EXPR_BEG;
12686|   280k|    return c;
12687|       |
12688|  55.7k|  case '[':
  ------------------
  |  Branch (12688:3): [True: 55.7k, False: 5.67M]
  ------------------
12689|  55.7k|    p->paren_nest++;
12690|  55.7k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12690:9): [True: 0, False: 55.7k]
  |  Branch (12690:36): [True: 0, False: 55.7k]
  ------------------
12691|      0|      p->lstate = EXPR_ARG;
12692|      0|      p->paren_nest--;
12693|      0|      if ((c = nextc(p)) == ']') {
  ------------------
  |  Branch (12693:11): [True: 0, False: 0]
  ------------------
12694|      0|        if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12694:13): [True: 0, False: 0]
  ------------------
12695|      0|          return tASET;
12696|      0|        }
12697|      0|        pushback(p, c);
12698|      0|        return tAREF;
12699|      0|      }
12700|      0|      pushback(p, c);
12701|      0|      return '[';
12702|      0|    }
12703|  55.7k|    else if (IS_BEG()) {
  ------------------
  |  |11139|  55.7k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 55.7k, False: 0]
  |  |  |  Branch (11139:44): [True: 0, False: 0]
  |  |  |  Branch (11139:69): [True: 0, False: 0]
  |  |  |  Branch (11139:96): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12704|  55.7k|      c = tLBRACK;
12705|  55.7k|    }
12706|      0|    else if (IS_ARG() && space_seen) {
  ------------------
  |  |11137|      0|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  ------------------
  |  |  |  Branch (11137:19): [True: 0, False: 0]
  |  |  |  Branch (11137:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12706:26): [True: 0, False: 0]
  ------------------
12707|      0|      c = tLBRACK;
12708|      0|    }
12709|  55.7k|    p->lstate = EXPR_BEG;
12710|  55.7k|    COND_PUSH(0);
  ------------------
  |  |  114|  55.7k|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|  55.7k|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12711|  55.7k|    CMDARG_PUSH(0);
  ------------------
  |  |  119|  55.7k|#define CMDARG_PUSH(n)  BITSTACK_PUSH(p->cmdarg_stack, (n))
  |  |  ------------------
  |  |  |  |  109|  55.7k|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12712|  55.7k|    return c;
12713|       |
12714|  3.61k|  case '{':
  ------------------
  |  Branch (12714:3): [True: 3.61k, False: 5.72M]
  ------------------
12715|  3.61k|    if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
  ------------------
  |  Branch (12715:9): [True: 0, False: 3.61k]
  |  Branch (12715:24): [True: 0, False: 0]
  ------------------
12716|      0|      p->lstate = EXPR_BEG;
12717|      0|      p->lpar_beg = 0;
12718|      0|      p->paren_nest--;
12719|      0|      COND_PUSH(0);
  ------------------
  |  |  114|      0|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12720|      0|      CMDARG_PUSH(0);
  ------------------
  |  |  119|      0|#define CMDARG_PUSH(n)  BITSTACK_PUSH(p->cmdarg_stack, (n))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12721|      0|      return tLAMBEG;
12722|      0|    }
12723|  3.61k|    if (IS_ARG() || p->lstate == EXPR_END || p->lstate == EXPR_ENDFN)
  ------------------
  |  |11137|  7.22k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  ------------------
  |  |  |  Branch (11137:19): [True: 0, False: 3.61k]
  |  |  |  Branch (11137:44): [True: 0, False: 3.61k]
  |  |  ------------------
  ------------------
  |  Branch (12723:21): [True: 0, False: 3.61k]
  |  Branch (12723:46): [True: 0, False: 3.61k]
  ------------------
12724|      0|      c = '{';          /* block (primary) */
12725|  3.61k|    else if (p->lstate == EXPR_ENDARG)
  ------------------
  |  Branch (12725:14): [True: 0, False: 3.61k]
  ------------------
12726|      0|      c = tLBRACE_ARG;  /* block (expr) */
12727|  3.61k|    else
12728|  3.61k|      c = tLBRACE;      /* hash */
12729|  3.61k|    COND_PUSH(0);
  ------------------
  |  |  114|  3.61k|#define COND_PUSH(n)    BITSTACK_PUSH(p->cond_stack, (n))
  |  |  ------------------
  |  |  |  |  109|  3.61k|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12730|  3.61k|    CMDARG_PUSH(0);
  ------------------
  |  |  119|  3.61k|#define CMDARG_PUSH(n)  BITSTACK_PUSH(p->cmdarg_stack, (n))
  |  |  ------------------
  |  |  |  |  109|  3.61k|#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
  |  |  ------------------
  ------------------
12731|  3.61k|    p->lstate = EXPR_BEG;
12732|  3.61k|    return c;
12733|       |
12734|      0|  case '\\':
  ------------------
  |  Branch (12734:3): [True: 0, False: 5.72M]
  ------------------
12735|      0|    c = nextc(p);
12736|      0|    if (c == '\n') {
  ------------------
  |  Branch (12736:9): [True: 0, False: 0]
  ------------------
12737|      0|      p->lineno+=nlines; nlines=1;
12738|      0|      p->column = 0;
12739|      0|      space_seen = 1;
12740|      0|      goto retry; /* skip \\n */
12741|      0|    }
12742|      0|    pushback(p, c);
12743|      0|    return '\\';
12744|       |
12745|  9.50k|  case '%':
  ------------------
  |  Branch (12745:3): [True: 9.50k, False: 5.71M]
  ------------------
12746|  9.50k|    if (IS_BEG()) {
  ------------------
  |  |11139|  9.50k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 0, False: 9.50k]
  |  |  |  Branch (11139:44): [True: 0, False: 9.50k]
  |  |  |  Branch (11139:69): [True: 0, False: 9.50k]
  |  |  |  Branch (11139:96): [True: 0, False: 9.50k]
  |  |  ------------------
  ------------------
12747|      0|      int term;
12748|      0|      int paren;
12749|       |
12750|      0|      c = nextc(p);
12751|      0|      quotation:
12752|      0|      if (c < 0 || !ISALNUM(c)) {
  ------------------
  |  | 1344|      0|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (12752:11): [True: 0, False: 0]
  ------------------
12753|      0|        term = c;
12754|      0|        c = 'Q';
12755|      0|      }
12756|      0|      else {
12757|      0|        term = nextc(p);
12758|      0|        if (ISALNUM(term)) {
  ------------------
  |  | 1344|      0|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  ------------------
  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
12759|      0|          yyerror(p, "unknown type of %string");
12760|      0|          return 0;
12761|      0|        }
12762|      0|      }
12763|      0|      if (c < 0 || term < 0) {
  ------------------
  |  Branch (12763:11): [True: 0, False: 0]
  |  Branch (12763:20): [True: 0, False: 0]
  ------------------
12764|      0|        yyerror(p, "unterminated quoted string meets end of file");
12765|      0|        return 0;
12766|      0|      }
12767|      0|      paren = term;
12768|      0|      if (term == '(') term = ')';
  ------------------
  |  Branch (12768:11): [True: 0, False: 0]
  ------------------
12769|      0|      else if (term == '[') term = ']';
  ------------------
  |  Branch (12769:16): [True: 0, False: 0]
  ------------------
12770|      0|      else if (term == '{') term = '}';
  ------------------
  |  Branch (12770:16): [True: 0, False: 0]
  ------------------
12771|      0|      else if (term == '<') term = '>';
  ------------------
  |  Branch (12771:16): [True: 0, False: 0]
  ------------------
12772|      0|      else paren = 0;
12773|       |
12774|      0|      switch (c) {
12775|      0|      case 'Q':
  ------------------
  |  Branch (12775:7): [True: 0, False: 0]
  ------------------
12776|      0|        p->lex_strterm = new_strterm(p, str_dquote, term, paren);
12777|      0|        return tSTRING_BEG;
12778|       |
12779|      0|      case 'q':
  ------------------
  |  Branch (12779:7): [True: 0, False: 0]
  ------------------
12780|      0|        p->lex_strterm = new_strterm(p, str_squote, term, paren);
12781|      0|        return parse_string(p);
12782|       |
12783|      0|      case 'W':
  ------------------
  |  Branch (12783:7): [True: 0, False: 0]
  ------------------
12784|      0|        p->lex_strterm = new_strterm(p, str_dword, term, paren);
12785|      0|        return tWORDS_BEG;
12786|       |
12787|      0|      case 'w':
  ------------------
  |  Branch (12787:7): [True: 0, False: 0]
  ------------------
12788|      0|        p->lex_strterm = new_strterm(p, str_sword, term, paren);
12789|      0|        return tWORDS_BEG;
12790|       |
12791|      0|      case 'x':
  ------------------
  |  Branch (12791:7): [True: 0, False: 0]
  ------------------
12792|      0|        p->lex_strterm = new_strterm(p, str_xquote, term, paren);
12793|      0|        return tXSTRING_BEG;
12794|       |
12795|      0|      case 'r':
  ------------------
  |  Branch (12795:7): [True: 0, False: 0]
  ------------------
12796|      0|        p->lex_strterm = new_strterm(p, str_regexp, term, paren);
12797|      0|        return tREGEXP_BEG;
12798|       |
12799|      0|      case 's':
  ------------------
  |  Branch (12799:7): [True: 0, False: 0]
  ------------------
12800|      0|        p->lex_strterm = new_strterm(p, str_ssym, term, paren);
12801|      0|        return tSYMBEG;
12802|       |
12803|      0|      case 'I':
  ------------------
  |  Branch (12803:7): [True: 0, False: 0]
  ------------------
12804|      0|        p->lex_strterm = new_strterm(p, str_dsymbols, term, paren);
12805|      0|        return tSYMBOLS_BEG;
12806|       |
12807|      0|      case 'i':
  ------------------
  |  Branch (12807:7): [True: 0, False: 0]
  ------------------
12808|      0|        p->lex_strterm = new_strterm(p, str_ssymbols, term, paren);
12809|      0|        return tSYMBOLS_BEG;
12810|       |
12811|      0|      default:
  ------------------
  |  Branch (12811:7): [True: 0, False: 0]
  ------------------
12812|      0|        yyerror(p, "unknown type of %string");
12813|      0|        return 0;
12814|      0|      }
12815|      0|    }
12816|  9.50k|    if ((c = nextc(p)) == '=') {
  ------------------
  |  Branch (12816:9): [True: 0, False: 9.50k]
  ------------------
12817|      0|      pylval.id = intern_op(mod);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern_op(mod);
  ------------------
  |  |  155|      0|#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
  |  |  ------------------
  |  |  |  |   20|      0|#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
  |  |  ------------------
  ------------------
12818|      0|      p->lstate = EXPR_BEG;
12819|      0|      return tOP_ASGN;
12820|      0|    }
12821|  9.50k|    if (IS_SPCARG(c)) {
  ------------------
  |  |11140|  9.50k|#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  |11137|  19.0k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 9.50k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 9.50k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
  |  |  ------------------
  |  |  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11140:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12822|      0|      goto quotation;
12823|      0|    }
12824|  9.50k|    if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
  ------------------
  |  Branch (12824:9): [True: 0, False: 9.50k]
  |  Branch (12824:36): [True: 0, False: 9.50k]
  ------------------
12825|      0|      p->lstate = EXPR_ARG;
12826|      0|    }
12827|  9.50k|    else {
12828|  9.50k|      p->lstate = EXPR_BEG;
12829|  9.50k|    }
12830|  9.50k|    pushback(p, c);
12831|  9.50k|    return '%';
12832|       |
12833|      0|  case '$':
  ------------------
  |  Branch (12833:3): [True: 0, False: 5.72M]
  ------------------
12834|      0|    p->lstate = EXPR_END;
12835|      0|    token_column = newtok(p);
12836|      0|    c = nextc(p);
12837|      0|    if (c < 0) {
  ------------------
  |  Branch (12837:9): [True: 0, False: 0]
  ------------------
12838|      0|      yyerror(p, "incomplete global variable syntax");
12839|      0|      return 0;
12840|      0|    }
12841|      0|    switch (c) {
12842|      0|    case '_':     /* $_: last read line string */
  ------------------
  |  Branch (12842:5): [True: 0, False: 0]
  ------------------
12843|      0|      c = nextc(p);
12844|      0|      if (c >= 0 && identchar(c)) { /* if there is more after _ it is a variable */
  ------------------
  |  |  105|      0|#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1344|      0|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1336|      0|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  |  |  ------------------
  |  |  |  Branch (105:37): [True: 0, False: 0]
  |  |  |  Branch (105:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12844:11): [True: 0, False: 0]
  ------------------
12845|      0|        tokadd(p, '$');
12846|      0|        tokadd(p, c);
12847|      0|        break;
12848|      0|      }
12849|      0|      pushback(p, c);
12850|      0|      c = '_';
12851|       |      /* fall through */
12852|      0|    case '~':     /* $~: match-data */
  ------------------
  |  Branch (12852:5): [True: 0, False: 0]
  ------------------
12853|      0|    case '*':     /* $*: argv */
  ------------------
  |  Branch (12853:5): [True: 0, False: 0]
  ------------------
12854|      0|    case '$':     /* $$: pid */
  ------------------
  |  Branch (12854:5): [True: 0, False: 0]
  ------------------
12855|      0|    case '?':     /* $?: last status */
  ------------------
  |  Branch (12855:5): [True: 0, False: 0]
  ------------------
12856|      0|    case '!':     /* $!: error string */
  ------------------
  |  Branch (12856:5): [True: 0, False: 0]
  ------------------
12857|      0|    case '@':     /* $@: error position */
  ------------------
  |  Branch (12857:5): [True: 0, False: 0]
  ------------------
12858|      0|    case '/':     /* $/: input record separator */
  ------------------
  |  Branch (12858:5): [True: 0, False: 0]
  ------------------
12859|      0|    case '\\':    /* $\: output record separator */
  ------------------
  |  Branch (12859:5): [True: 0, False: 0]
  ------------------
12860|      0|    case ';':     /* $;: field separator */
  ------------------
  |  Branch (12860:5): [True: 0, False: 0]
  ------------------
12861|      0|    case ',':     /* $,: output field separator */
  ------------------
  |  Branch (12861:5): [True: 0, False: 0]
  ------------------
12862|      0|    case '.':     /* $.: last read line number */
  ------------------
  |  Branch (12862:5): [True: 0, False: 0]
  ------------------
12863|      0|    case '=':     /* $=: ignorecase */
  ------------------
  |  Branch (12863:5): [True: 0, False: 0]
  ------------------
12864|      0|    case ':':     /* $:: load path */
  ------------------
  |  Branch (12864:5): [True: 0, False: 0]
  ------------------
12865|      0|    case '<':     /* $<: reading filename */
  ------------------
  |  Branch (12865:5): [True: 0, False: 0]
  ------------------
12866|      0|    case '>':     /* $>: default output handle */
  ------------------
  |  Branch (12866:5): [True: 0, False: 0]
  ------------------
12867|      0|    case '\"':    /* $": already loaded files */
  ------------------
  |  Branch (12867:5): [True: 0, False: 0]
  ------------------
12868|      0|      tokadd(p, '$');
12869|      0|      tokadd(p, c);
12870|      0|      tokfix(p);
12871|      0|      pylval.id = intern(tok(p), toklen(p));
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern(tok(p), toklen(p));
  ------------------
  |  |  153|      0|#define intern(s,len) intern_gen(p,(s),(len))
  ------------------
12872|      0|      return tGVAR;
12873|       |
12874|      0|    case '-':
  ------------------
  |  Branch (12874:5): [True: 0, False: 0]
  ------------------
12875|      0|      tokadd(p, '$');
12876|      0|      tokadd(p, c);
12877|      0|      c = nextc(p);
12878|      0|      pushback(p, c);
12879|      0|      gvar:
12880|      0|      tokfix(p);
12881|      0|      pylval.id = intern(tok(p), toklen(p));
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                    pylval.id = intern(tok(p), toklen(p));
  ------------------
  |  |  153|      0|#define intern(s,len) intern_gen(p,(s),(len))
  ------------------
12882|      0|      return tGVAR;
12883|       |
12884|      0|    case '&':     /* $&: last match */
  ------------------
  |  Branch (12884:5): [True: 0, False: 0]
  ------------------
12885|      0|    case '`':     /* $`: string before last match */
  ------------------
  |  Branch (12885:5): [True: 0, False: 0]
  ------------------
12886|      0|    case '\'':    /* $': string after last match */
  ------------------
  |  Branch (12886:5): [True: 0, False: 0]
  ------------------
12887|      0|    case '+':     /* $+: string matches last pattern */
  ------------------
  |  Branch (12887:5): [True: 0, False: 0]
  ------------------
12888|      0|      if (last_state == EXPR_FNAME) {
  ------------------
  |  Branch (12888:11): [True: 0, False: 0]
  ------------------
12889|      0|        tokadd(p, '$');
12890|      0|        tokadd(p, c);
12891|      0|        goto gvar;
12892|      0|      }
12893|      0|      pylval.nd = new_back_ref(p, c);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12894|      0|      return tBACK_REF;
12895|       |
12896|      0|    case '1': case '2': case '3':
  ------------------
  |  Branch (12896:5): [True: 0, False: 0]
  |  Branch (12896:15): [True: 0, False: 0]
  |  Branch (12896:25): [True: 0, False: 0]
  ------------------
12897|      0|    case '4': case '5': case '6':
  ------------------
  |  Branch (12897:5): [True: 0, False: 0]
  |  Branch (12897:15): [True: 0, False: 0]
  |  Branch (12897:25): [True: 0, False: 0]
  ------------------
12898|      0|    case '7': case '8': case '9':
  ------------------
  |  Branch (12898:5): [True: 0, False: 0]
  |  Branch (12898:15): [True: 0, False: 0]
  |  Branch (12898:25): [True: 0, False: 0]
  ------------------
12899|      0|      do {
12900|      0|        tokadd(p, c);
12901|      0|        c = nextc(p);
12902|      0|      } while (c >= 0 && ISDIGIT(c));
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (12902:16): [True: 0, False: 0]
  ------------------
12903|      0|      pushback(p, c);
12904|      0|      if (last_state == EXPR_FNAME) goto gvar;
  ------------------
  |  Branch (12904:11): [True: 0, False: 0]
  ------------------
12905|      0|      tokfix(p);
12906|      0|      {
12907|      0|        mrb_int n;
12908|      0|        if (!mrb_read_int(tok(p), NULL, NULL, &n)) {
  ------------------
  |  Branch (12908:13): [True: 0, False: 0]
  ------------------
12909|      0|          yywarning(p, "capture group index too big; always nil");
12910|      0|          return keyword_nil;
12911|      0|        }
12912|      0|        pylval.nd = new_nth_ref(p, (int)n);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
12913|      0|      }
12914|      0|      return tNTH_REF;
12915|       |
12916|      0|    default:
  ------------------
  |  Branch (12916:5): [True: 0, False: 0]
  ------------------
12917|      0|      if (!identchar(c)) {
  ------------------
  |  |  105|      0|#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1344|      0|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1336|      0|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  |  |  ------------------
  |  |  |  Branch (105:37): [True: 0, False: 0]
  |  |  |  Branch (105:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12918|      0|        pushback(p,  c);
12919|      0|        return '$';
12920|      0|      }
12921|       |      /* fall through */
12922|      0|    case '0':
  ------------------
  |  Branch (12922:5): [True: 0, False: 0]
  ------------------
12923|      0|      tokadd(p, '$');
12924|      0|    }
12925|      0|    break;
12926|       |
12927|  31.8k|    case '@':
  ------------------
  |  Branch (12927:5): [True: 31.8k, False: 5.69M]
  ------------------
12928|  31.8k|      c = nextc(p);
12929|  31.8k|      token_column = newtok(p);
12930|  31.8k|      tokadd(p, '@');
12931|  31.8k|      if (c == '@') {
  ------------------
  |  Branch (12931:11): [True: 0, False: 31.8k]
  ------------------
12932|      0|        tokadd(p, '@');
12933|      0|        c = nextc(p);
12934|      0|      }
12935|  31.8k|      if (c < 0) {
  ------------------
  |  Branch (12935:11): [True: 0, False: 31.8k]
  ------------------
12936|      0|        if (p->tidx == 1) {
  ------------------
  |  Branch (12936:13): [True: 0, False: 0]
  ------------------
12937|      0|          yyerror(p, "incomplete instance variable syntax");
12938|      0|        }
12939|      0|        else {
12940|      0|          yyerror(p, "incomplete class variable syntax");
12941|      0|        }
12942|      0|        return 0;
12943|      0|      }
12944|  31.8k|      else if (ISDIGIT(c)) {
  ------------------
  |  | 1342|  31.8k|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 31.8k]
  |  |  ------------------
  ------------------
12945|      0|        if (p->tidx == 1) {
  ------------------
  |  Branch (12945:13): [True: 0, False: 0]
  ------------------
12946|      0|          yyerror_c(p, "wrong instance variable name: @", c);
12947|      0|        }
12948|      0|        else {
12949|      0|          yyerror_c(p, "wrong class variable name: @@", c);
12950|      0|        }
12951|      0|        return 0;
12952|      0|      }
12953|  31.8k|      if (!identchar(c)) {
  ------------------
  |  |  105|  31.8k|#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1344|  63.6k|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1341|  63.6k|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1341:20): [True: 31.8k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1336|      0|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  |  |  ------------------
  |  |  |  Branch (105:37): [True: 0, False: 0]
  |  |  |  Branch (105:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12954|      0|        pushback(p, c);
12955|      0|        return '@';
12956|      0|      }
12957|  31.8k|      break;
12958|       |
12959|  31.8k|    case '_':
  ------------------
  |  Branch (12959:5): [True: 0, False: 5.72M]
  ------------------
12960|      0|      token_column = newtok(p);
12961|      0|      break;
12962|       |
12963|   558k|    default:
  ------------------
  |  Branch (12963:5): [True: 558k, False: 5.16M]
  ------------------
12964|   558k|      if (!identchar(c)) {
  ------------------
  |  |  105|   558k|#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1344|  1.11M|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1341|  1.11M|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1341:20): [True: 558k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1336|      0|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  |  |  ------------------
  |  |  |  Branch (105:37): [True: 0, False: 0]
  |  |  |  Branch (105:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
12965|      0|        char buf[36];
12966|      0|        const char s[] = "Invalid char in expression: 0x";
12967|      0|        const char hexdigits[] = "0123456789ABCDEF";
12968|       |
12969|      0|        strcpy(buf, s);
12970|      0|        buf[sizeof(s)-1] = hexdigits[(c & 0xf0) >> 4];
12971|      0|        buf[sizeof(s)]   = hexdigits[(c & 0x0f)];
12972|      0|        buf[sizeof(s)+1] = 0;
12973|      0|        yyerror(p, buf);
12974|      0|        goto retry;
12975|      0|      }
12976|       |
12977|   558k|      token_column = newtok(p);
12978|   558k|      break;
12979|  5.72M|  }
12980|       |
12981|  3.50M|  do {
12982|  3.50M|    tokadd(p, c);
12983|  3.50M|    c = nextc(p);
12984|  3.50M|    if (c < 0) break;
  ------------------
  |  Branch (12984:9): [True: 0, False: 3.50M]
  ------------------
12985|  3.50M|  } while (identchar(c));
  ------------------
  |  |  105|  3.50M|#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1344|  7.01M|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1341|  7.01M|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1341:20): [True: 1.96M, False: 1.54M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1342|  1.54M|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1342:20): [True: 646k, False: 899k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1336|   590k|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  |  |  ------------------
  |  |  |  Branch (105:37): [True: 308k, False: 590k]
  |  |  |  Branch (105:51): [True: 0, False: 590k]
  |  |  ------------------
  ------------------
12986|   590k|  if (token_column == 0 && toklen(p) == 7 && (c < 0 || c == '\n') &&
  ------------------
  |  Branch (12986:7): [True: 344k, False: 246k]
  |  Branch (12986:28): [True: 106k, False: 237k]
  |  Branch (12986:47): [True: 0, False: 106k]
  |  Branch (12986:56): [True: 0, False: 106k]
  ------------------
12987|   590k|      strncmp(tok(p), "__END__", toklen(p)) == 0)
  ------------------
  |  Branch (12987:7): [True: 0, False: 0]
  ------------------
12988|      0|    return -1;
12989|       |
12990|   590k|  switch (tok(p)[0]) {
12991|  31.8k|  case '@': case '$':
  ------------------
  |  Branch (12991:3): [True: 31.8k, False: 558k]
  |  Branch (12991:13): [True: 0, False: 590k]
  ------------------
12992|  31.8k|    pushback(p, c);
12993|  31.8k|    break;
12994|   558k|  default:
  ------------------
  |  Branch (12994:3): [True: 558k, False: 31.8k]
  ------------------
12995|   558k|    if ((c == '!' || c == '?') && !peek(p, '=')) {
  ------------------
  |  |10981|  1.05k|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
  |  Branch (12995:10): [True: 1.05k, False: 557k]
  |  Branch (12995:22): [True: 0, False: 557k]
  |  Branch (12995:35): [True: 1.05k, False: 0]
  ------------------
12996|  1.05k|      tokadd(p, c);
12997|  1.05k|    }
12998|   557k|    else {
12999|   557k|      pushback(p, c);
13000|   557k|    }
13001|   590k|  }
13002|   590k|  tokfix(p);
13003|   590k|  {
13004|   590k|    int result = 0;
13005|       |
13006|   590k|    switch (tok(p)[0]) {
13007|      0|    case '$':
  ------------------
  |  Branch (13007:5): [True: 0, False: 590k]
  ------------------
13008|      0|      p->lstate = EXPR_END;
13009|      0|      result = tGVAR;
13010|      0|      break;
13011|  31.8k|    case '@':
  ------------------
  |  Branch (13011:5): [True: 31.8k, False: 558k]
  ------------------
13012|  31.8k|      p->lstate = EXPR_END;
13013|  31.8k|      if (tok(p)[1] == '@')
  ------------------
  |  Branch (13013:11): [True: 0, False: 31.8k]
  ------------------
13014|      0|        result = tCVAR;
13015|  31.8k|      else
13016|  31.8k|        result = tIVAR;
13017|  31.8k|      break;
13018|       |
13019|      0|    case '_':
  ------------------
  |  Branch (13019:5): [True: 0, False: 590k]
  ------------------
13020|      0|      if (p->lstate != EXPR_FNAME && toklen(p) == 2 && ISDIGIT(tok(p)[1]) && p->nvars) {
  ------------------
  |  | 1342|      0|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (13020:11): [True: 0, False: 0]
  |  Branch (13020:38): [True: 0, False: 0]
  |  Branch (13020:78): [True: 0, False: 0]
  ------------------
13021|      0|        int n = tok(p)[1] - '0';
13022|      0|        int nvar;
13023|       |
13024|      0|        if (n > 0) {
  ------------------
  |  Branch (13024:13): [True: 0, False: 0]
  ------------------
13025|      0|          node *nvars = p->nvars->cdr;
13026|       |
13027|      0|          while (nvars) {
  ------------------
  |  Branch (13027:18): [True: 0, False: 0]
  ------------------
13028|      0|            nvar = intn(nvars->car);
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
13029|      0|            if (nvar == -2) break; /* top of the scope */
  ------------------
  |  Branch (13029:17): [True: 0, False: 0]
  ------------------
13030|      0|            if (nvar > 0) {
  ------------------
  |  Branch (13030:17): [True: 0, False: 0]
  ------------------
13031|      0|              yywarning(p, "numbered parameter used in outer block");
13032|      0|              break;
13033|      0|            }
13034|      0|            nvars->car = nint(-1);
  ------------------
  |  |  134|      0|#define nint(x) ((node*)(intptr_t)(x))
  ------------------
13035|      0|            nvars = nvars->cdr;
13036|      0|          }
13037|      0|          nvar = intn(p->nvars->car);
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
13038|      0|          if (nvar != -2) {     /* numbered parameters never appear on toplevel */
  ------------------
  |  Branch (13038:15): [True: 0, False: 0]
  ------------------
13039|      0|            if (nvar == -1) {
  ------------------
  |  Branch (13039:17): [True: 0, False: 0]
  ------------------
13040|      0|              yywarning(p, "numbered parameter used in inner block");
13041|      0|            }
13042|      0|            else {
13043|      0|              p->nvars->car = nint(nvar > n ? nvar : n);
  ------------------
  |  |  134|      0|#define nint(x) ((node*)(intptr_t)(x))
  |  |  ------------------
  |  |  |  Branch (134:36): [True: 0, False: 0]
  |  |  ------------------
  ------------------
13044|      0|            }
13045|      0|            pylval.num = n;
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
13046|      0|            p->lstate = EXPR_END;
13047|      0|            return tNUMPARAM;
13048|      0|          }
13049|      0|        }
13050|      0|      }
13051|       |      /* fall through */
13052|   558k|    default:
  ------------------
  |  Branch (13052:5): [True: 558k, False: 31.8k]
  ------------------
13053|   558k|      if (toklast(p) == '!' || toklast(p) == '?') {
  ------------------
  |  Branch (13053:11): [True: 1.05k, False: 557k]
  |  Branch (13053:32): [True: 0, False: 557k]
  ------------------
13054|  1.05k|        result = tFID;
13055|  1.05k|      }
13056|   557k|      else {
13057|   557k|        if (p->lstate == EXPR_FNAME) {
  ------------------
  |  Branch (13057:13): [True: 1.74k, False: 556k]
  ------------------
13058|  1.74k|          if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
  ------------------
  |  |10981|  1.74k|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
                        if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
  ------------------
  |  |10981|  1.74k|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
  |  Branch (13058:15): [True: 0, False: 1.74k]
  |  Branch (13058:40): [True: 0, False: 0]
  |  Branch (13058:57): [True: 0, False: 0]
  ------------------
13059|  1.74k|              (!peek(p, '=') || (peek_n(p, '>', 1)))) {
  ------------------
  |  |10981|      0|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
  |  Branch (13059:16): [True: 0, False: 0]
  |  Branch (13059:33): [True: 0, False: 0]
  ------------------
13060|      0|            result = tIDENTIFIER;
13061|      0|            tokadd(p, c);
13062|      0|            tokfix(p);
13063|      0|          }
13064|  1.74k|          else {
13065|  1.74k|            pushback(p, c);
13066|  1.74k|          }
13067|  1.74k|          if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
  ------------------
  |  |10981|  1.74k|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
                        if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
  ------------------
  |  |10981|  1.74k|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
  |  Branch (13067:15): [True: 0, False: 1.74k]
  |  Branch (13067:40): [True: 0, False: 0]
  |  Branch (13067:57): [True: 0, False: 0]
  ------------------
13068|  1.74k|              (!peek(p, '=') || (peek_n(p, '>', 1)))) {
  ------------------
  |  |10981|      0|#define peek(p,c) peek_n((p), (c), 0)
  ------------------
  |  Branch (13068:16): [True: 0, False: 0]
  |  Branch (13068:33): [True: 0, False: 0]
  ------------------
13069|      0|            result = tIDENTIFIER;
13070|      0|            tokadd(p, c);
13071|      0|            tokfix(p);
13072|      0|          }
13073|  1.74k|          else {
13074|  1.74k|            pushback(p, c);
13075|  1.74k|          }
13076|  1.74k|        }
13077|   557k|        if (result == 0 && ISUPPER(tok(p)[0])) {
  ------------------
  |  | 1339|   557k|#define ISUPPER(c) (((unsigned)(c) - 'A') < 26)
  |  |  ------------------
  |  |  |  Branch (1339:20): [True: 46.2k, False: 511k]
  |  |  ------------------
  ------------------
  |  Branch (13077:13): [True: 557k, False: 0]
  ------------------
13078|  46.2k|          result = tCONSTANT;
13079|  46.2k|        }
13080|   511k|        else {
13081|   511k|          result = tIDENTIFIER;
13082|   511k|        }
13083|   557k|      }
13084|       |
13085|   558k|      if (IS_LABEL_POSSIBLE()) {
  ------------------
  |  |11141|   558k|#define IS_LABEL_POSSIBLE() ((p->lstate == EXPR_BEG && !cmd_state) || IS_ARG())
  |  |  ------------------
  |  |  |  |11137|   455k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (11137:19): [True: 0, False: 455k]
  |  |  |  |  |  Branch (11137:44): [True: 0, False: 455k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (11141:31): [True: 447k, False: 111k]
  |  |  |  Branch (11141:56): [True: 102k, False: 344k]
  |  |  ------------------
  ------------------
13086|   102k|        if (IS_LABEL_SUFFIX(0)) {
  ------------------
  |  |11142|   102k|#define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
  |  |  ------------------
  |  |  |  Branch (11142:29): [True: 3.08k, False: 99.7k]
  |  |  |  Branch (11142:51): [True: 0, False: 3.08k]
  |  |  ------------------
  ------------------
13087|      0|          p->lstate = EXPR_END;
13088|      0|          tokfix(p);
13089|      0|          pylval.id = intern(tok(p), toklen(p));
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                        pylval.id = intern(tok(p), toklen(p));
  ------------------
  |  |  153|      0|#define intern(s,len) intern_gen(p,(s),(len))
  ------------------
13090|      0|          return tIDENTIFIER;
13091|      0|        }
13092|   102k|      }
13093|   558k|      if (p->lstate != EXPR_DOT) {
  ------------------
  |  Branch (13093:11): [True: 459k, False: 98.9k]
  ------------------
13094|   459k|        const struct kwtable *kw;
13095|       |
13096|       |        /* See if it is a reserved word.  */
13097|   459k|        kw = mrb_reserved_word(tok(p), toklen(p));
13098|   459k|        if (kw) {
  ------------------
  |  Branch (13098:13): [True: 125k, False: 334k]
  ------------------
13099|   125k|          enum mrb_lex_state_enum state = p->lstate;
13100|   125k|          pylval.num = p->lineno;
  ------------------
  |  |10739|   125k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
13101|   125k|          p->lstate = kw->state;
13102|   125k|          if (state == EXPR_FNAME) {
  ------------------
  |  Branch (13102:15): [True: 0, False: 125k]
  ------------------
13103|      0|            pylval.id = intern_cstr(kw->name);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
                          pylval.id = intern_cstr(kw->name);
  ------------------
  |  |  146|      0|#define intern_cstr(s) intern_cstr_gen(p,(s))
  ------------------
13104|      0|            return kw->id[0];
13105|      0|          }
13106|   125k|          if (p->lstate == EXPR_BEG) {
  ------------------
  |  Branch (13106:15): [True: 49.3k, False: 76.5k]
  ------------------
13107|  49.3k|            p->cmd_start = TRUE;
  ------------------
  |  |   54|  49.3k|#  define TRUE 1
  ------------------
13108|  49.3k|          }
13109|   125k|          if (kw->id[0] == keyword_do) {
  ------------------
  |  Branch (13109:15): [True: 0, False: 125k]
  ------------------
13110|      0|            if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
  ------------------
  |  Branch (13110:17): [True: 0, False: 0]
  |  Branch (13110:32): [True: 0, False: 0]
  ------------------
13111|      0|              p->lpar_beg = 0;
13112|      0|              p->paren_nest--;
13113|      0|              return keyword_do_LAMBDA;
13114|      0|            }
13115|      0|            if (COND_P()) return keyword_do_cond;
  ------------------
  |  |  117|      0|#define COND_P()        BITSTACK_SET_P(p->cond_stack)
  |  |  ------------------
  |  |  |  |  112|      0|#define BITSTACK_SET_P(stack)   ((stack)&1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (112:33): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
13116|      0|            if (CMDARG_P() && state != EXPR_CMDARG)
  ------------------
  |  |  122|      0|#define CMDARG_P()      BITSTACK_SET_P(p->cmdarg_stack)
  |  |  ------------------
  |  |  |  |  112|      0|#define BITSTACK_SET_P(stack)   ((stack)&1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (112:33): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (13116:31): [True: 0, False: 0]
  ------------------
13117|      0|              return keyword_do_block;
13118|      0|            if (state == EXPR_ENDARG || state == EXPR_BEG)
  ------------------
  |  Branch (13118:17): [True: 0, False: 0]
  |  Branch (13118:41): [True: 0, False: 0]
  ------------------
13119|      0|              return keyword_do_block;
13120|      0|            return keyword_do;
13121|      0|          }
13122|   125k|          if (state == EXPR_BEG || state == EXPR_VALUE || state == EXPR_CLASS)
  ------------------
  |  Branch (13122:15): [True: 119k, False: 6.20k]
  |  Branch (13122:36): [True: 0, False: 6.20k]
  |  Branch (13122:59): [True: 0, False: 6.20k]
  ------------------
13123|   119k|            return kw->id[0];
13124|  6.20k|          else {
13125|  6.20k|            if (kw->id[0] != kw->id[1])
  ------------------
  |  Branch (13125:17): [True: 0, False: 6.20k]
  ------------------
13126|      0|              p->lstate = EXPR_BEG;
13127|  6.20k|            return kw->id[1];
13128|  6.20k|          }
13129|   125k|        }
13130|   459k|      }
13131|       |
13132|   433k|      if (IS_BEG() || p->lstate == EXPR_DOT || IS_ARG()) {
  ------------------
  |  |11139|   866k|#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
  |  |  ------------------
  |  |  |  Branch (11139:19): [True: 327k, False: 105k]
  |  |  |  Branch (11139:44): [True: 0, False: 105k]
  |  |  |  Branch (11139:69): [True: 4.89k, False: 100k]
  |  |  |  Branch (11139:96): [True: 0, False: 100k]
  |  |  ------------------
  ------------------
                    if (IS_BEG() || p->lstate == EXPR_DOT || IS_ARG()) {
  ------------------
  |  |11137|  1.74k|#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
  |  |  ------------------
  |  |  |  Branch (11137:19): [True: 0, False: 1.74k]
  |  |  |  Branch (11137:44): [True: 0, False: 1.74k]
  |  |  ------------------
  ------------------
  |  Branch (13132:23): [True: 98.9k, False: 1.74k]
  ------------------
13133|   431k|        if (cmd_state) {
  ------------------
  |  Branch (13133:13): [True: 256k, False: 174k]
  ------------------
13134|   256k|          p->lstate = EXPR_CMDARG;
13135|   256k|        }
13136|   174k|        else {
13137|   174k|          p->lstate = EXPR_ARG;
13138|   174k|        }
13139|   431k|      }
13140|  1.74k|      else if (p->lstate == EXPR_FNAME) {
  ------------------
  |  Branch (13140:16): [True: 1.74k, False: 0]
  ------------------
13141|  1.74k|        p->lstate = EXPR_ENDFN;
13142|  1.74k|      }
13143|      0|      else {
13144|      0|        p->lstate = EXPR_END;
13145|      0|      }
13146|   590k|    }
13147|   464k|    {
13148|   464k|      mrb_sym ident = intern(tok(p), toklen(p));
  ------------------
  |  |  153|   464k|#define intern(s,len) intern_gen(p,(s),(len))
  ------------------
13149|       |
13150|   464k|      pylval.id = ident;
  ------------------
  |  |10739|   464k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
13151|   464k|      if (last_state != EXPR_DOT && ISLOWER(tok(p)[0]) && local_var_p(p, ident)) {
  ------------------
  |  | 1340|   830k|#define ISLOWER(c) (((unsigned)(c) - 'a') < 26)
  |  |  ------------------
  |  |  |  Branch (1340:20): [True: 290k, False: 74.9k]
  |  |  ------------------
  ------------------
  |  Branch (13151:11): [True: 365k, False: 98.9k]
  |  Branch (13151:59): [True: 126k, False: 164k]
  ------------------
13152|   126k|        p->lstate = EXPR_END;
13153|   126k|      }
13154|   464k|    }
13155|   464k|    return result;
13156|   590k|  }
13157|   590k|}
y.tab.c:parse_string:
11432|   258k|{
11433|   258k|  int c;
11434|   258k|  string_type type = (string_type)p->lex_strterm->type;
11435|   258k|  int nest_level = p->lex_strterm->level;
11436|   258k|  int beg = p->lex_strterm->paren;
11437|   258k|  int end = p->lex_strterm->term;
11438|   258k|  parser_heredoc_info *hinfo = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_info(p) : NULL;
  ------------------
  |  |   81|   258k|#define STR_FUNC_HEREDOC 0x40
  ------------------
  |  Branch (11438:32): [True: 0, False: 258k]
  ------------------
11439|       |
11440|   258k|  mrb_bool unindent = hinfo && hinfo->remove_indent;
  ------------------
  |  Branch (11440:23): [True: 0, False: 258k]
  |  Branch (11440:32): [True: 0, False: 0]
  ------------------
11441|   258k|  mrb_bool head = hinfo && hinfo->line_head;
  ------------------
  |  Branch (11441:19): [True: 0, False: 258k]
  |  Branch (11441:28): [True: 0, False: 0]
  ------------------
11442|   258k|  mrb_bool empty = TRUE;
  ------------------
  |  |   54|   258k|#  define TRUE 1
  ------------------
11443|   258k|  size_t spaces = 0;
11444|   258k|  size_t pos = -1;
11445|   258k|  node *escaped = NULL;
11446|   258k|  node *nspaces = NULL;
11447|       |
11448|   258k|  if (beg == 0) beg = -3;       /* should never happen */
  ------------------
  |  Branch (11448:7): [True: 258k, False: 0]
  ------------------
11449|   258k|  if (end == 0) end = -3;
  ------------------
  |  Branch (11449:7): [True: 0, False: 258k]
  ------------------
11450|   258k|  newtok(p);
11451|  5.12M|  while ((c = nextc(p)) != end || nest_level != 0) {
  ------------------
  |  Branch (11451:10): [True: 4.87M, False: 258k]
  |  Branch (11451:35): [True: 0, False: 258k]
  ------------------
11452|  4.87M|    pos++;
11453|  4.87M|    if (hinfo && (c == '\n' || c < 0)) {
  ------------------
  |  Branch (11453:9): [True: 0, False: 4.87M]
  |  Branch (11453:19): [True: 0, False: 0]
  |  Branch (11453:32): [True: 0, False: 0]
  ------------------
11454|      0|      mrb_bool line_head;
11455|      0|      tokadd(p, '\n');
11456|      0|      tokfix(p);
11457|      0|      p->lineno++;
11458|      0|      p->column = 0;
11459|      0|      line_head = hinfo->line_head;
11460|      0|      hinfo->line_head = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
11461|      0|      if (line_head) {
  ------------------
  |  Branch (11461:11): [True: 0, False: 0]
  ------------------
11462|       |        /* check whether end of heredoc */
11463|      0|        const char *s = tok(p);
11464|      0|        int len = toklen(p);
11465|      0|        if (hinfo->allow_indent) {
  ------------------
  |  Branch (11465:13): [True: 0, False: 0]
  ------------------
11466|      0|          while (ISSPACE(*s) && len > 0) {
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (11466:33): [True: 0, False: 0]
  ------------------
11467|      0|            s++;
11468|      0|            len--;
11469|      0|          }
11470|      0|        }
11471|      0|        if (hinfo->term_len > 0 && len-1 == hinfo->term_len && strncmp(s, hinfo->term, len-1) == 0) {
  ------------------
  |  Branch (11471:13): [True: 0, False: 0]
  |  Branch (11471:36): [True: 0, False: 0]
  |  Branch (11471:64): [True: 0, False: 0]
  ------------------
11472|      0|          heredoc_remove_indent(p, hinfo);
11473|      0|          return tHEREDOC_END;
11474|      0|        }
11475|      0|      }
11476|      0|      if (c < 0) {
  ------------------
  |  Branch (11476:11): [True: 0, False: 0]
  ------------------
11477|      0|        char buf[256];
11478|      0|        const char s1[] = "can't find heredoc delimiter \"";
11479|      0|        const char s2[] = "\" anywhere before EOF";
11480|       |
11481|      0|        if (sizeof(s1)+sizeof(s2)+strlen(hinfo->term)+1 >= sizeof(buf)) {
  ------------------
  |  Branch (11481:13): [True: 0, False: 0]
  ------------------
11482|      0|          yyerror(p, "can't find heredoc delimiter anywhere before EOF");
11483|      0|        }
11484|      0|        else {
11485|      0|          strcpy(buf, s1);
11486|      0|          strcat(buf, hinfo->term);
11487|      0|          strcat(buf, s2);
11488|      0|          yyerror(p, buf);
11489|      0|        }
11490|      0|        return 0;
11491|      0|      }
11492|      0|      node *nd = new_str(p, tok(p), toklen(p));
11493|      0|      pylval.nd = nd;
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11494|      0|      if (unindent && head) {
  ------------------
  |  Branch (11494:11): [True: 0, False: 0]
  |  Branch (11494:23): [True: 0, False: 0]
  ------------------
11495|      0|        nspaces = push(nspaces, nint(spaces));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
11496|      0|        heredoc_push_indented(p, hinfo, nd->cdr, escaped, nspaces, empty && line_head);
  ------------------
  |  Branch (11496:68): [True: 0, False: 0]
  |  Branch (11496:77): [True: 0, False: 0]
  ------------------
11497|      0|      }
11498|      0|      return tHD_STRING_MID;
11499|      0|    }
11500|  4.87M|    if (unindent && empty) {
  ------------------
  |  Branch (11500:9): [True: 0, False: 4.87M]
  |  Branch (11500:21): [True: 0, False: 0]
  ------------------
11501|      0|      if (c == '\t')
  ------------------
  |  Branch (11501:11): [True: 0, False: 0]
  ------------------
11502|      0|        spaces += 8;
11503|      0|      else if (ISSPACE(c))
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11504|      0|        spaces++;
11505|      0|      else
11506|      0|        empty = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
11507|      0|    }
11508|  4.87M|    if (c < 0) {
  ------------------
  |  Branch (11508:9): [True: 0, False: 4.87M]
  ------------------
11509|      0|      yyerror(p, "unterminated string meets end of file");
11510|      0|      return 0;
11511|      0|    }
11512|  4.87M|    else if (c == beg) {
  ------------------
  |  Branch (11512:14): [True: 0, False: 4.87M]
  ------------------
11513|      0|      nest_level++;
11514|      0|      p->lex_strterm->level = nest_level;
11515|      0|    }
11516|  4.87M|    else if (c == end) {
  ------------------
  |  Branch (11516:14): [True: 0, False: 4.87M]
  ------------------
11517|      0|      nest_level--;
11518|      0|      p->lex_strterm->level = nest_level;
11519|      0|    }
11520|  4.87M|    else if (c == '\\') {
  ------------------
  |  Branch (11520:14): [True: 0, False: 4.87M]
  ------------------
11521|      0|      c = nextc(p);
11522|      0|      if (type & STR_FUNC_EXPAND) {
  ------------------
  |  |   76|      0|#define STR_FUNC_EXPAND  0x02
  ------------------
  |  Branch (11522:11): [True: 0, False: 0]
  ------------------
11523|      0|        if (c == end || c == beg) {
  ------------------
  |  Branch (11523:13): [True: 0, False: 0]
  |  Branch (11523:25): [True: 0, False: 0]
  ------------------
11524|      0|          tokadd(p, c);
11525|      0|        }
11526|      0|        else if (c == '\n') {
  ------------------
  |  Branch (11526:18): [True: 0, False: 0]
  ------------------
11527|      0|          p->lineno++;
11528|      0|          p->column = 0;
11529|      0|          if (unindent) {
  ------------------
  |  Branch (11529:15): [True: 0, False: 0]
  ------------------
11530|      0|            nspaces = push(nspaces, nint(spaces));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
11531|      0|            escaped = push(escaped, nint(pos));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
11532|      0|            pos--;
11533|      0|            empty = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
11534|      0|            spaces = 0;
11535|      0|          }
11536|      0|          if (type & STR_FUNC_ARRAY) {
  ------------------
  |  |   80|      0|#define STR_FUNC_ARRAY   0x20
  ------------------
  |  Branch (11536:15): [True: 0, False: 0]
  ------------------
11537|      0|            tokadd(p, '\n');
11538|      0|          }
11539|      0|        }
11540|      0|        else if (type & STR_FUNC_REGEXP) {
  ------------------
  |  |   77|      0|#define STR_FUNC_REGEXP  0x04
  ------------------
  |  Branch (11540:18): [True: 0, False: 0]
  ------------------
11541|      0|          tokadd(p, '\\');
11542|      0|          tokadd(p, c);
11543|      0|        }
11544|      0|        else if (c == 'u' && peek(p, '{')) {
  ------------------
  |  |10981|      0|#define peek(p,c) peek_n((p), (c), 0)
  |  |  ------------------
  |  |  |  Branch (10981:19): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (11544:18): [True: 0, False: 0]
  ------------------
11545|       |          /* \u{xxxx xxxx xxxx} form */
11546|      0|          nextc(p);
11547|      0|          while (1) {
  ------------------
  |  Branch (11547:18): [Folded - Ignored]
  ------------------
11548|      0|            do c = nextc(p); while (ISSPACE(c));
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11549|      0|            if (c == '}') break;
  ------------------
  |  Branch (11549:17): [True: 0, False: 0]
  ------------------
11550|      0|            pushback(p, c);
11551|      0|            c = read_escape_unicode(p, 8);
11552|      0|            if (c < 0) break;
  ------------------
  |  Branch (11552:17): [True: 0, False: 0]
  ------------------
11553|      0|            tokadd(p, -c);
11554|      0|          }
11555|      0|          if (hinfo)
  ------------------
  |  Branch (11555:15): [True: 0, False: 0]
  ------------------
11556|      0|            hinfo->line_head = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
11557|      0|        }
11558|      0|        else {
11559|      0|          pushback(p, c);
11560|      0|          tokadd(p, read_escape(p));
11561|      0|          if (hinfo)
  ------------------
  |  Branch (11561:15): [True: 0, False: 0]
  ------------------
11562|      0|            hinfo->line_head = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
11563|      0|        }
11564|      0|      }
11565|      0|      else {
11566|      0|        if (c != beg && c != end) {
  ------------------
  |  Branch (11566:13): [True: 0, False: 0]
  |  Branch (11566:25): [True: 0, False: 0]
  ------------------
11567|      0|          if (c == '\n') {
  ------------------
  |  Branch (11567:15): [True: 0, False: 0]
  ------------------
11568|      0|            p->lineno++;
11569|      0|            p->column = 0;
11570|      0|          }
11571|      0|          if (!(c == '\\' || ((type & STR_FUNC_ARRAY) && ISSPACE(c)))) {
  ------------------
  |  |   80|      0|#define STR_FUNC_ARRAY   0x20
  ------------------
                        if (!(c == '\\' || ((type & STR_FUNC_ARRAY) && ISSPACE(c)))) {
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (11571:17): [True: 0, False: 0]
  |  Branch (11571:31): [True: 0, False: 0]
  ------------------
11572|      0|            tokadd(p, '\\');
11573|      0|          }
11574|      0|        }
11575|      0|        tokadd(p, c);
11576|      0|      }
11577|      0|      continue;
11578|      0|    }
11579|  4.87M|    else if ((c == '#') && (type & STR_FUNC_EXPAND)) {
  ------------------
  |  |   76|      0|#define STR_FUNC_EXPAND  0x02
  ------------------
  |  Branch (11579:14): [True: 0, False: 4.87M]
  |  Branch (11579:28): [True: 0, False: 0]
  ------------------
11580|      0|      c = nextc(p);
11581|      0|      if (c == '{') {
  ------------------
  |  Branch (11581:11): [True: 0, False: 0]
  ------------------
11582|      0|        tokfix(p);
11583|      0|        p->lstate = EXPR_BEG;
11584|      0|        p->cmd_start = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
11585|      0|        node *nd = new_str(p, tok(p), toklen(p));
11586|      0|        pylval.nd = nd;
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11587|      0|        if (hinfo) {
  ------------------
  |  Branch (11587:13): [True: 0, False: 0]
  ------------------
11588|      0|          if (unindent && head) {
  ------------------
  |  Branch (11588:15): [True: 0, False: 0]
  |  Branch (11588:27): [True: 0, False: 0]
  ------------------
11589|      0|            nspaces = push(nspaces, nint(spaces));
  ------------------
  |  |  268|      0|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|      0|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
11590|      0|            heredoc_push_indented(p, hinfo, nd->cdr, escaped, nspaces, FALSE);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
11591|      0|          }
11592|      0|          hinfo->line_head = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
11593|      0|          return tHD_STRING_PART;
11594|      0|        }
11595|      0|        return tSTRING_PART;
11596|      0|      }
11597|      0|      tokadd(p, '#');
11598|      0|      pushback(p, c);
11599|      0|      continue;
11600|      0|    }
11601|  4.87M|    if ((type & STR_FUNC_ARRAY) && ISSPACE(c)) {
  ------------------
  |  |   80|  4.87M|#define STR_FUNC_ARRAY   0x20
  ------------------
                  if ((type & STR_FUNC_ARRAY) && ISSPACE(c)) {
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (11601:9): [True: 0, False: 4.87M]
  ------------------
11602|      0|      if (toklen(p) == 0) {
  ------------------
  |  Branch (11602:11): [True: 0, False: 0]
  ------------------
11603|      0|        do {
11604|      0|          if (c == '\n') {
  ------------------
  |  Branch (11604:15): [True: 0, False: 0]
  ------------------
11605|      0|            p->lineno++;
11606|      0|            p->column = 0;
11607|      0|            heredoc_treat_nextline(p);
11608|      0|            if (p->parsing_heredoc != NULL) {
  ------------------
  |  Branch (11608:17): [True: 0, False: 0]
  ------------------
11609|      0|              return tHD_LITERAL_DELIM;
11610|      0|            }
11611|      0|          }
11612|      0|          c = nextc(p);
11613|      0|        } while (ISSPACE(c));
  ------------------
  |  | 1338|      0|#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5)
  |  |  ------------------
  |  |  |  Branch (1338:21): [True: 0, False: 0]
  |  |  |  Branch (1338:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
11614|      0|        pushback(p, c);
11615|      0|        return tLITERAL_DELIM;
11616|      0|      }
11617|      0|      else {
11618|      0|        pushback(p, c);
11619|      0|        tokfix(p);
11620|      0|        pylval.nd = new_str(p, tok(p), toklen(p));
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11621|      0|        return tSTRING_MID;
11622|      0|      }
11623|      0|    }
11624|  4.87M|    if (c == '\n') {
  ------------------
  |  Branch (11624:9): [True: 0, False: 4.87M]
  ------------------
11625|      0|      p->lineno++;
11626|      0|      p->column = 0;
11627|      0|    }
11628|  4.87M|    tokadd(p, c);
11629|  4.87M|  }
11630|       |
11631|   258k|  tokfix(p);
11632|   258k|  p->lstate = EXPR_ENDARG;
11633|   258k|  end_strterm(p);
11634|       |
11635|   258k|  if (type & STR_FUNC_XQUOTE) {
  ------------------
  |  |   82|   258k|#define STR_FUNC_XQUOTE  0x80
  ------------------
  |  Branch (11635:7): [True: 0, False: 258k]
  ------------------
11636|      0|    pylval.nd = new_xstr(p, tok(p), toklen(p));
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11637|      0|    return tXSTRING;
11638|      0|  }
11639|       |
11640|   258k|  if (type & STR_FUNC_REGEXP) {
  ------------------
  |  |   77|   258k|#define STR_FUNC_REGEXP  0x04
  ------------------
  |  Branch (11640:7): [True: 0, False: 258k]
  ------------------
11641|      0|    int f = 0;
11642|      0|    int re_opt;
11643|      0|    char *s = strndup(tok(p), toklen(p));
  ------------------
  |  |  280|      0|#define strndup(s,len) parser_strndup(p, s, len)
  ------------------
11644|      0|    char flags[3];
11645|      0|    char *flag = flags;
11646|      0|    char enc = '\0';
11647|      0|    char *encp;
11648|      0|    char *dup;
11649|       |
11650|      0|    newtok(p);
11651|      0|    while (re_opt = nextc(p), re_opt >= 0 && ISALPHA(re_opt)) {
  ------------------
  |  | 1341|      0|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  ------------------
  |  |  |  Branch (1341:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (11651:12): [True: 0, False: 0]
  |  Branch (11651:31): [True: 0, False: 0]
  ------------------
11652|      0|      switch (re_opt) {
11653|      0|      case 'i': f |= 1; break;
  ------------------
  |  Branch (11653:7): [True: 0, False: 0]
  ------------------
11654|      0|      case 'x': f |= 2; break;
  ------------------
  |  Branch (11654:7): [True: 0, False: 0]
  ------------------
11655|      0|      case 'm': f |= 4; break;
  ------------------
  |  Branch (11655:7): [True: 0, False: 0]
  ------------------
11656|      0|      case 'u': f |= 16; break;
  ------------------
  |  Branch (11656:7): [True: 0, False: 0]
  ------------------
11657|      0|      case 'n': f |= 32; break;
  ------------------
  |  Branch (11657:7): [True: 0, False: 0]
  ------------------
11658|      0|      case 'o': break;
  ------------------
  |  Branch (11658:7): [True: 0, False: 0]
  ------------------
11659|      0|      default: tokadd(p, re_opt); break;
  ------------------
  |  Branch (11659:7): [True: 0, False: 0]
  ------------------
11660|      0|      }
11661|      0|    }
11662|      0|    pushback(p, re_opt);
11663|      0|    if (toklen(p)) {
  ------------------
  |  Branch (11663:9): [True: 0, False: 0]
  ------------------
11664|      0|      char msg[128];
11665|       |
11666|      0|      strcpy(msg, "unknown regexp option");
11667|      0|      tokfix(p);
11668|      0|      if (toklen(p) > 1) {
  ------------------
  |  Branch (11668:11): [True: 0, False: 0]
  ------------------
11669|      0|        strcat(msg, "s");
11670|      0|      }
11671|      0|      strcat(msg, " - ");
11672|      0|      strncat(msg, tok(p), sizeof(msg) - strlen(msg) - 1);
11673|      0|      yyerror(p, msg);
11674|      0|    }
11675|      0|    if (f != 0) {
  ------------------
  |  Branch (11675:9): [True: 0, False: 0]
  ------------------
11676|      0|      if (f & 1) *flag++ = 'i';
  ------------------
  |  Branch (11676:11): [True: 0, False: 0]
  ------------------
11677|      0|      if (f & 2) *flag++ = 'x';
  ------------------
  |  Branch (11677:11): [True: 0, False: 0]
  ------------------
11678|      0|      if (f & 4) *flag++ = 'm';
  ------------------
  |  Branch (11678:11): [True: 0, False: 0]
  ------------------
11679|      0|      if (f & 16) enc = 'u';
  ------------------
  |  Branch (11679:11): [True: 0, False: 0]
  ------------------
11680|      0|      if (f & 32) enc = 'n';
  ------------------
  |  Branch (11680:11): [True: 0, False: 0]
  ------------------
11681|      0|    }
11682|      0|    if (flag > flags) {
  ------------------
  |  Branch (11682:9): [True: 0, False: 0]
  ------------------
11683|      0|      dup = strndup(flags, (size_t)(flag - flags));
  ------------------
  |  |  280|      0|#define strndup(s,len) parser_strndup(p, s, len)
  ------------------
11684|      0|    }
11685|      0|    else {
11686|      0|      dup = NULL;
11687|      0|    }
11688|      0|    if (enc) {
  ------------------
  |  Branch (11688:9): [True: 0, False: 0]
  ------------------
11689|      0|      encp = strndup(&enc, 1);
  ------------------
  |  |  280|      0|#define strndup(s,len) parser_strndup(p, s, len)
  ------------------
11690|      0|    }
11691|      0|    else {
11692|      0|      encp = NULL;
11693|      0|    }
11694|      0|    pylval.nd = new_regx(p, s, dup, encp);
  ------------------
  |  |10739|      0|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11695|       |
11696|      0|    return tREGEXP;
11697|      0|  }
11698|   258k|  pylval.nd = new_str(p, tok(p), toklen(p));
  ------------------
  |  |10739|   258k|#define pylval  (*((YYSTYPE*)(p->ylval)))
  ------------------
11699|       |
11700|   258k|  return tSTRING;
11701|   258k|}
y.tab.c:end_strterm:
 1450|   258k|{
 1451|   258k|  parser_lex_strterm *term = p->lex_strterm->prev;
 1452|   258k|  parser_pfree(p->lex_strterm);
  ------------------
  |  |  185|   258k|#define parser_pfree(ptr) do { if (sizeof(node) <= sizeof(*(ptr))) cons_free((node*)ptr);} while (0)
  |  |  ------------------
  |  |  |  |  172|   258k|#define cons_free(c) cons_free_gen(p, (c))
  |  |  ------------------
  |  |  |  Branch (185:36): [Folded - Ignored]
  |  |  |  Branch (185:99): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1453|   258k|  p->lex_strterm = term;
 1454|   258k|}
y.tab.c:parser_strndup:
  272|   964k|{
  273|   964k|  char *b = (char*)parser_palloc(p, len+1);
  274|       |
  275|   964k|  memcpy(b, s, len);
  276|   964k|  b[len] = '\0';
  277|   964k|  return b;
  278|   964k|}
y.tab.c:nextc:
10898|  16.9M|{
10899|  16.9M|  int c;
10900|       |
10901|  16.9M|  if (p->pb) {
  ------------------
  |  Branch (10901:7): [True: 2.95M, False: 14.0M]
  ------------------
10902|  2.95M|    node *tmp;
10903|       |
10904|  2.95M|    c = intn(p->pb->car);
  ------------------
  |  |  135|  2.95M|#define intn(x) ((int)(intptr_t)(x))
  ------------------
10905|  2.95M|    tmp = p->pb;
10906|  2.95M|    p->pb = p->pb->cdr;
10907|  2.95M|    cons_free(tmp);
  ------------------
  |  |  172|  2.95M|#define cons_free(c) cons_free_gen(p, (c))
  ------------------
10908|  2.95M|  }
10909|  14.0M|  else {
10910|  14.0M|    c = nextc0(p);
10911|  14.0M|    if (c < 0) goto eof;
  ------------------
  |  Branch (10911:9): [True: 3.49k, False: 14.0M]
  ------------------
10912|  14.0M|  }
10913|  16.9M|  if (c >= 0) {
  ------------------
  |  Branch (10913:7): [True: 16.9M, False: 0]
  ------------------
10914|  16.9M|    p->column++;
10915|  16.9M|  }
10916|  16.9M|  if (c == '\r') {
  ------------------
  |  Branch (10916:7): [True: 0, False: 16.9M]
  ------------------
10917|      0|    const int lf = nextc0(p);
10918|      0|    if (lf == '\n') {
  ------------------
  |  Branch (10918:9): [True: 0, False: 0]
  ------------------
10919|      0|      return '\n';
10920|      0|    }
10921|      0|    if (lf > 0) pushback(p, lf);
  ------------------
  |  Branch (10921:9): [True: 0, False: 0]
  ------------------
10922|      0|  }
10923|  16.9M|  return c;
10924|       |
10925|  3.49k|  eof:
10926|  3.49k|  if (!p->cxt) return -1;
  ------------------
  |  Branch (10926:7): [True: 3.49k, False: 0]
  ------------------
10927|      0|  else {
10928|      0|    if (p->cxt->partial_hook(p) < 0)
  ------------------
  |  Branch (10928:9): [True: 0, False: 0]
  ------------------
10929|      0|      return -1;                /* end of program(s) */
10930|      0|    return -2;                  /* end of a file in the program files */
10931|      0|  }
10932|  3.49k|}
y.tab.c:nextc0:
10879|  14.0M|{
10880|  14.0M|  if (p->s && p->s < p->send) {
  ------------------
  |  Branch (10880:7): [True: 14.0M, False: 0]
  |  Branch (10880:15): [True: 14.0M, False: 3.49k]
  ------------------
10881|  14.0M|    return (unsigned char)*p->s++;
10882|  14.0M|  }
10883|  3.49k|  else {
10884|  3.49k|#ifndef MRB_NO_STDIO
10885|  3.49k|    int c;
10886|       |
10887|  3.49k|    if (p->f) {
  ------------------
  |  Branch (10887:9): [True: 0, False: 3.49k]
  ------------------
10888|      0|      c = fgetc(p->f);
10889|      0|      if (!feof(p->f)) return c;
  ------------------
  |  Branch (10889:11): [True: 0, False: 0]
  ------------------
10890|      0|    }
10891|  3.49k|#endif
10892|  3.49k|    return -1;
10893|  3.49k|  }
10894|  14.0M|}
y.tab.c:peek_n:
10978|   106k|{
10979|   106k|  return peekc_n(p, n) == c && c >= 0;
  ------------------
  |  Branch (10979:10): [True: 6.16k, False: 100k]
  |  Branch (10979:32): [True: 6.16k, False: 0]
  ------------------
10980|   106k|}
y.tab.c:pushback:
10936|  2.84M|{
10937|  2.84M|  if (c >= 0) {
  ------------------
  |  Branch (10937:7): [True: 2.84M, False: 0]
  ------------------
10938|  2.84M|    p->column--;
10939|  2.84M|  }
10940|  2.84M|  p->pb = cons(nint(c), p->pb);
  ------------------
  |  |  210|  2.84M|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
10941|  2.84M|}
y.tab.c:peekc_n:
10957|   106k|{
10958|   106k|  node *list = 0;
10959|   106k|  int c0;
10960|       |
10961|   110k|  do {
10962|   110k|    c0 = nextc(p);
10963|   110k|    if (c0 == -1) return c0;    /* do not skip partial EOF */
  ------------------
  |  Branch (10963:9): [True: 0, False: 110k]
  ------------------
10964|   110k|    if (c0 >= 0) --p->column;
  ------------------
  |  Branch (10964:9): [True: 110k, False: 0]
  ------------------
10965|   110k|    list = push(list, nint(c0));
  ------------------
  |  |  268|   110k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|   110k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
10966|   110k|  } while(n--);
  ------------------
  |  Branch (10966:11): [True: 3.08k, False: 106k]
  ------------------
10967|   106k|  if (p->pb) {
  ------------------
  |  Branch (10967:7): [True: 0, False: 106k]
  ------------------
10968|      0|    p->pb = append(list, p->pb);
  ------------------
  |  |  267|      0|#define append(a,b) append_gen(p,(a),(b))
  ------------------
10969|      0|  }
10970|   106k|  else {
10971|   106k|    p->pb = list;
10972|   106k|  }
10973|   106k|  return c0;
10974|   106k|}
y.tab.c:new_strterm:
 1438|   258k|{
 1439|   258k|  parser_lex_strterm *lex = (parser_lex_strterm*)parser_palloc(p, sizeof(parser_lex_strterm));
 1440|   258k|  lex->type = type;
 1441|   258k|  lex->level = 0;
 1442|   258k|  lex->term = term;
 1443|   258k|  lex->paren = paren;
 1444|   258k|  lex->prev = p->lex_strterm;
 1445|   258k|  return lex;
 1446|   258k|}
y.tab.c:newtok:
11042|  1.55M|{
11043|  1.55M|  if (p->tokbuf != p->buf) {
  ------------------
  |  Branch (11043:7): [True: 630, False: 1.55M]
  ------------------
11044|    630|    mrb_free(p->mrb, p->tokbuf);
11045|    630|    p->tokbuf = p->buf;
11046|    630|    p->tsiz = MRB_PARSER_TOKBUF_SIZE;
  ------------------
  |  |  112|    630|#define MRB_PARSER_TOKBUF_SIZE 256
  ------------------
11047|    630|  }
11048|  1.55M|  p->tidx = 0;
11049|  1.55M|  return p->column - 1;
11050|  1.55M|}
y.tab.c:tokadd:
11054|  9.10M|{
11055|  9.10M|  char utf8[4];
11056|  9.10M|  int i, len;
11057|       |
11058|       |  /* mrb_assert(-0x10FFFF <= c && c <= 0xFF); */
11059|  9.10M|  if (c >= 0) {
  ------------------
  |  Branch (11059:7): [True: 9.10M, False: 0]
  ------------------
11060|       |    /* Single byte from source or non-Unicode escape */
11061|  9.10M|    utf8[0] = (char)c;
11062|  9.10M|    len = 1;
11063|  9.10M|  }
11064|      0|  else {
11065|       |    /* Unicode character */
11066|      0|    c = -c;
11067|      0|    if (c < 0x80) {
  ------------------
  |  Branch (11067:9): [True: 0, False: 0]
  ------------------
11068|      0|      utf8[0] = (char)c;
11069|      0|      len = 1;
11070|      0|    }
11071|      0|    else if (c < 0x800) {
  ------------------
  |  Branch (11071:14): [True: 0, False: 0]
  ------------------
11072|      0|      utf8[0] = (char)(0xC0 | (c >> 6));
11073|      0|      utf8[1] = (char)(0x80 | (c & 0x3F));
11074|      0|      len = 2;
11075|      0|    }
11076|      0|    else if (c < 0x10000) {
  ------------------
  |  Branch (11076:14): [True: 0, False: 0]
  ------------------
11077|      0|      utf8[0] = (char)(0xE0 |  (c >> 12)        );
11078|      0|      utf8[1] = (char)(0x80 | ((c >>  6) & 0x3F));
11079|      0|      utf8[2] = (char)(0x80 | ( c        & 0x3F));
11080|      0|      len = 3;
11081|      0|    }
11082|      0|    else {
11083|      0|      utf8[0] = (char)(0xF0 |  (c >> 18)        );
11084|      0|      utf8[1] = (char)(0x80 | ((c >> 12) & 0x3F));
11085|      0|      utf8[2] = (char)(0x80 | ((c >>  6) & 0x3F));
11086|      0|      utf8[3] = (char)(0x80 | ( c        & 0x3F));
11087|      0|      len = 4;
11088|      0|    }
11089|      0|  }
11090|  9.10M|  if (p->tidx+len >= p->tsiz) {
  ------------------
  |  Branch (11090:7): [True: 10.6k, False: 9.09M]
  ------------------
11091|  10.6k|    if (p->tsiz >= MRB_PARSER_TOKBUF_MAX) {
  ------------------
  |  |  111|  10.6k|#define MRB_PARSER_TOKBUF_MAX (UINT16_MAX-1)
  ------------------
  |  Branch (11091:9): [True: 9.17k, False: 1.49k]
  ------------------
11092|  9.17k|      p->tidx += len;
11093|  9.17k|      return;
11094|  9.17k|    }
11095|  1.49k|    p->tsiz *= 2;
11096|  1.49k|    if (p->tokbuf == p->buf) {
  ------------------
  |  Branch (11096:9): [True: 630, False: 867]
  ------------------
11097|    630|      p->tokbuf = (char*)mrb_malloc(p->mrb, p->tsiz);
11098|    630|      memcpy(p->tokbuf, p->buf, MRB_PARSER_TOKBUF_SIZE);
  ------------------
  |  |  112|    630|#define MRB_PARSER_TOKBUF_SIZE 256
  ------------------
11099|    630|    }
11100|    867|    else {
11101|    867|      p->tokbuf = (char*)mrb_realloc(p->mrb, p->tokbuf, p->tsiz);
11102|    867|    }
11103|  1.49k|  }
11104|  18.2M|  for (i = 0; i < len; i++) {
  ------------------
  |  Branch (11104:15): [True: 9.10M, False: 9.10M]
  ------------------
11105|  9.10M|    p->tokbuf[p->tidx++] = utf8[i];
11106|  9.10M|  }
11107|  9.10M|}
y.tab.c:tokfix:
11117|  1.54M|{
11118|  1.54M|  if (p->tidx >= MRB_PARSER_TOKBUF_MAX) {
  ------------------
  |  |  111|  1.54M|#define MRB_PARSER_TOKBUF_MAX (UINT16_MAX-1)
  ------------------
  |  Branch (11118:7): [True: 40, False: 1.54M]
  ------------------
11119|     40|    p->tidx = MRB_PARSER_TOKBUF_MAX-1;
  ------------------
  |  |  111|     40|#define MRB_PARSER_TOKBUF_MAX (UINT16_MAX-1)
  ------------------
11120|     40|    yyerror(p, "string too long (truncated)");
11121|     40|  }
11122|  1.54M|  p->tokbuf[p->tidx] = '\0';
11123|  1.54M|}
y.tab.c:tok:
11127|  4.01M|{
11128|  4.01M|  return p->tokbuf;
11129|  4.01M|}
y.tab.c:toklen:
11133|  1.53M|{
11134|  1.53M|  return p->tidx;
11135|  1.53M|}
y.tab.c:number_literal_suffix:
11705|   705k|{
11706|   705k|  int c, result = 0;
11707|   705k|  node *list = 0;
11708|   705k|  int column = p->column;
11709|   705k|  int mask = NUM_SUFFIX_R|NUM_SUFFIX_I;
  ------------------
  |  |  138|   705k|#define NUM_SUFFIX_R   (1<<0)
  ------------------
                int mask = NUM_SUFFIX_R|NUM_SUFFIX_I;
  ------------------
  |  |  139|   705k|#define NUM_SUFFIX_I   (1<<1)
  ------------------
11710|       |
11711|   705k|  while ((c = nextc(p)) != -1) {
  ------------------
  |  Branch (11711:10): [True: 705k, False: 0]
  ------------------
11712|   705k|    list = push(list, nint(c));
  ------------------
  |  |  268|   705k|#define push(a,b) append_gen(p,(a),list1(b))
  |  |  ------------------
  |  |  |  |  217|   705k|#define list1(a) list1_gen(p, (a))
  |  |  ------------------
  ------------------
11713|       |
11714|   705k|    if ((mask & NUM_SUFFIX_I) && c == 'i') {
  ------------------
  |  |  139|   705k|#define NUM_SUFFIX_I   (1<<1)
  ------------------
  |  Branch (11714:9): [True: 705k, False: 0]
  |  Branch (11714:34): [True: 0, False: 705k]
  ------------------
11715|      0|      result |= (mask & NUM_SUFFIX_I);
  ------------------
  |  |  139|      0|#define NUM_SUFFIX_I   (1<<1)
  ------------------
11716|      0|      mask &= ~NUM_SUFFIX_I;
  ------------------
  |  |  139|      0|#define NUM_SUFFIX_I   (1<<1)
  ------------------
11717|       |      /* r after i, rational of complex is disallowed */
11718|      0|      mask &= ~NUM_SUFFIX_R;
  ------------------
  |  |  138|      0|#define NUM_SUFFIX_R   (1<<0)
  ------------------
11719|      0|      continue;
11720|      0|    }
11721|   705k|    if ((mask & NUM_SUFFIX_R) && c == 'r') {
  ------------------
  |  |  138|   705k|#define NUM_SUFFIX_R   (1<<0)
  ------------------
  |  Branch (11721:9): [True: 705k, False: 0]
  |  Branch (11721:34): [True: 0, False: 705k]
  ------------------
11722|      0|      result |= (mask & NUM_SUFFIX_R);
  ------------------
  |  |  138|      0|#define NUM_SUFFIX_R   (1<<0)
  ------------------
11723|      0|      mask &= ~NUM_SUFFIX_R;
  ------------------
  |  |  138|      0|#define NUM_SUFFIX_R   (1<<0)
  ------------------
11724|      0|      continue;
11725|      0|    }
11726|   705k|    if (!ISASCII(c) || ISALPHA(c) || c == '_') {
  ------------------
  |  | 1336|  1.41M|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  ------------------
                  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
  ------------------
  |  | 1341|  1.41M|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  ------------------
  |  |  |  Branch (1341:20): [True: 0, False: 705k]
  |  |  ------------------
  ------------------
  |  Branch (11726:9): [True: 0, False: 705k]
  |  Branch (11726:38): [True: 0, False: 705k]
  ------------------
11727|      0|      p->column = column;
11728|      0|      if (p->pb) {
  ------------------
  |  Branch (11728:11): [True: 0, False: 0]
  ------------------
11729|      0|        p->pb = append(list, p->pb);
  ------------------
  |  |  267|      0|#define append(a,b) append_gen(p,(a),(b))
  ------------------
11730|      0|      }
11731|      0|      else {
11732|      0|        p->pb = list;
11733|      0|      }
11734|      0|      return 0;
11735|      0|    }
11736|   705k|    pushback(p, c);
11737|   705k|    break;
11738|   705k|  }
11739|   705k|  return result;
11740|   705k|}
y.tab.c:parser_strdup:
  284|   705k|{
  285|   705k|  return parser_strndup(p, s, strlen(s));
  286|   705k|}
y.tab.c:intern_gen:
  150|   464k|{
  151|   464k|  return mrb_intern(p->mrb, s, len);
  152|   464k|}
y.tab.c:toklast:
11111|  1.11M|{
11112|  1.11M|  return p->tokbuf[p->tidx-1];
11113|  1.11M|}
y.tab.c:intern_cstr_gen:
  143|   124k|{
  144|   124k|  return mrb_intern_cstr(p->mrb, s);
  145|   124k|}
y.tab.c:new_scope:
  442|  1.74k|{
  443|  1.74k|  return cons((node*)NODE_SCOPE, cons(locals_node(p), body));
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  444|  1.74k|}
y.tab.c:new_begin:
  449|   253k|{
  450|   253k|  if (body) {
  ------------------
  |  Branch (450:7): [True: 217k, False: 36.0k]
  ------------------
  451|   217k|    return list2((node*)NODE_BEGIN, body);
  ------------------
  |  |  224|   217k|#define list2(a,b) list2_gen(p, (a),(b))
  ------------------
  452|   217k|  }
  453|  36.0k|  return cons((node*)NODE_BEGIN, 0);
  ------------------
  |  |  210|  36.0k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  454|   253k|}
y.tab.c:local_switch:
  314|  1.74k|{
  315|  1.74k|  node *prev = p->locals;
  316|       |
  317|  1.74k|  p->locals = cons(0, 0);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  318|  1.74k|  return prev;
  319|  1.74k|}
y.tab.c:nvars_block:
  429|  1.74k|{
  430|  1.74k|  p->nvars = cons(nint(-2), p->nvars);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  431|  1.74k|}
y.tab.c:local_resume:
  323|  1.74k|{
  324|  1.74k|  p->locals = prev;
  325|  1.74k|}
y.tab.c:nvars_unnest:
  435|  1.74k|{
  436|  1.74k|  p->nvars = p->nvars->cdr;
  437|  1.74k|}
y.tab.c:list4_gen:
  235|   279k|{
  236|   279k|  return cons(a, cons(b, cons(c, cons(d, 0))));
  ------------------
  |  |  210|   279k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  237|   279k|}
y.tab.c:new_if:
  509|  26.0k|{
  510|  26.0k|  void_expr_error(p, a);
  511|  26.0k|  return list4((node*)NODE_IF, a, b, c);
  ------------------
  |  |  238|  26.0k|#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
  ------------------
  512|  26.0k|}
y.tab.c:cond:
 1368|  26.0k|{
 1369|  26.0k|  return n;
 1370|  26.0k|}
y.tab.c:new_asgn:
 1040|   214k|{
 1041|   214k|  void_expr_error(p, b);
 1042|   214k|  return cons((node*)NODE_ASGN, cons(a, b));
  ------------------
  |  |  210|   214k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 1043|   214k|}
y.tab.c:new_array:
  716|  55.7k|{
  717|  55.7k|  return cons((node*)NODE_ARRAY, a);
  ------------------
  |  |  210|  55.7k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  718|  55.7k|}
y.tab.c:new_lvar:
  761|   289k|{
  762|   289k|  return cons((node*)NODE_LVAR, nsym(sym));
  ------------------
  |  |  210|   289k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  763|   289k|}
y.tab.c:assignable:
 1386|   246k|{
 1387|   246k|  if (intn(lhs->car) == NODE_LVAR) {
  ------------------
  |  |  135|   246k|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (1387:7): [True: 214k, False: 31.8k]
  ------------------
 1388|   214k|    local_add(p, sym(lhs->cdr));
  ------------------
  |  |  132|   214k|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1389|   214k|  }
 1390|   246k|}
y.tab.c:local_add:
  395|   214k|{
  396|   214k|  if (!local_var_p(p, sym)) {
  ------------------
  |  Branch (396:7): [True: 160k, False: 53.6k]
  ------------------
  397|   160k|    local_add_f(p, sym);
  398|   160k|  }
  399|   214k|}
y.tab.c:new_op_asgn:
 1063|  31.8k|{
 1064|  31.8k|  void_expr_error(p, b);
 1065|  31.8k|  return list4((node*)NODE_OP_ASGN, a, nsym(op), b);
  ------------------
  |  |  238|  31.8k|#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
  ------------------
 1066|  31.8k|}
y.tab.c:new_call:
  578|   220k|{
  579|   220k|  node *n = list4(nint(pass?NODE_CALL:NODE_SCALL), a, nsym(b), c);
  ------------------
  |  |  238|   440k|#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
  |  |  ------------------
  |  |  |  Branch (238:38): [True: 220k, False: 0]
  |  |  ------------------
  ------------------
  580|   220k|  void_expr_error(p, a);
  581|   220k|  NODE_LINENO(n, a);
  ------------------
  |  |  125|   220k|#define NODE_LINENO(c,n) do {\
  |  |  126|   220k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 220k, False: 0]
  |  |  ------------------
  |  |  127|   220k|     (c)->filename_index = (n)->filename_index;\
  |  |  128|   220k|     (c)->lineno = (n)->lineno;\
  |  |  129|   220k|  }\
  |  |  130|   220k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  582|   220k|  return n;
  583|   220k|}
y.tab.c:void_expr_error:
10840|  1.28M|{
10841|  1.28M|  int c;
10842|       |
10843|  1.28M|  if (n == NULL) return;
  ------------------
  |  Branch (10843:7): [True: 0, False: 1.28M]
  ------------------
10844|  1.28M|  c = intn(n->car);
  ------------------
  |  |  135|  1.28M|#define intn(x) ((int)(intptr_t)(x))
  ------------------
10845|  1.28M|  switch (c) {
10846|      0|  case NODE_BREAK:
  ------------------
  |  Branch (10846:3): [True: 0, False: 1.28M]
  ------------------
10847|      0|  case NODE_RETURN:
  ------------------
  |  Branch (10847:3): [True: 0, False: 1.28M]
  ------------------
10848|      0|  case NODE_NEXT:
  ------------------
  |  Branch (10848:3): [True: 0, False: 1.28M]
  ------------------
10849|      0|  case NODE_REDO:
  ------------------
  |  Branch (10849:3): [True: 0, False: 1.28M]
  ------------------
10850|      0|  case NODE_RETRY:
  ------------------
  |  Branch (10850:3): [True: 0, False: 1.28M]
  ------------------
10851|      0|    yyerror(p, "void value expression");
10852|      0|    break;
10853|  3.21k|  case NODE_AND:
  ------------------
  |  Branch (10853:3): [True: 3.21k, False: 1.27M]
  ------------------
10854|  4.46k|  case NODE_OR:
  ------------------
  |  Branch (10854:3): [True: 1.24k, False: 1.28M]
  ------------------
10855|  4.46k|    if (n->cdr) {
  ------------------
  |  Branch (10855:9): [True: 4.46k, False: 0]
  ------------------
10856|  4.46k|      void_expr_error(p, n->cdr->car);
10857|  4.46k|      void_expr_error(p, n->cdr->cdr);
10858|  4.46k|    }
10859|  4.46k|    break;
10860|   146k|  case NODE_BEGIN:
  ------------------
  |  Branch (10860:3): [True: 146k, False: 1.13M]
  ------------------
10861|   146k|    if (n->cdr) {
  ------------------
  |  Branch (10861:9): [True: 139k, False: 6.78k]
  ------------------
10862|   635k|      while (n->cdr) {
  ------------------
  |  Branch (10862:14): [True: 496k, False: 139k]
  ------------------
10863|   496k|        n = n->cdr;
10864|   496k|      }
10865|   139k|      void_expr_error(p, n->car);
10866|   139k|    }
10867|   146k|    break;
10868|  1.13M|  default:
  ------------------
  |  Branch (10868:3): [True: 1.13M, False: 150k]
  ------------------
10869|  1.13M|    break;
10870|  1.28M|  }
10871|  1.28M|}
y.tab.c:defn_setup:
  839|  1.74k|{
  840|  1.74k|  node *n = d->cdr->cdr;
  841|       |
  842|  1.74k|  n->car = locals_node(p);
  843|  1.74k|  p->cmdarg_stack = intn(n->cdr->car);
  ------------------
  |  |  135|  1.74k|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  844|  1.74k|  n->cdr->car = a;
  845|  1.74k|  local_resume(p, n->cdr->cdr->car);
  846|  1.74k|  n->cdr->cdr->car = b;
  847|  1.74k|}
y.tab.c:new_and:
  700|  4.11k|{
  701|  4.11k|  void_expr_error(p, a);
  702|  4.11k|  return cons((node*)NODE_AND, cons(a, b));
  ------------------
  |  |  210|  4.11k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  703|  4.11k|}
y.tab.c:new_or:
  708|  2.09k|{
  709|  2.09k|  void_expr_error(p, a);
  710|  2.09k|  return cons((node*)NODE_OR, cons(a, b));
  ------------------
  |  |  210|  2.09k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  711|  2.09k|}
y.tab.c:new_def:
  833|  1.74k|{
  834|  1.74k|  return list5((node*)NODE_DEF, nsym(m), 0, a, b);
  ------------------
  |  |  245|  1.74k|#define list5(a,b,c,d,e) list5_gen(p, (a),(b),(c),(d),(e))
  ------------------
  835|  1.74k|}
y.tab.c:list5_gen:
  242|  1.74k|{
  243|  1.74k|  return cons(a, cons(b, cons(c, cons(d, cons(e, 0)))));
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  244|  1.74k|}
y.tab.c:new_fcall:
  588|  1.74k|{
  589|  1.74k|  node *n = list4((node*)NODE_FCALL, 0, nsym(b), c);
  ------------------
  |  |  238|  1.74k|#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
  ------------------
  590|  1.74k|  NODE_LINENO(n, c);
  ------------------
  |  |  125|  1.74k|#define NODE_LINENO(c,n) do {\
  |  |  126|  1.74k|  if (n) {\
  |  |  ------------------
  |  |  |  Branch (126:7): [True: 0, False: 1.74k]
  |  |  ------------------
  |  |  127|      0|     (c)->filename_index = (n)->filename_index;\
  |  |  128|      0|     (c)->lineno = (n)->lineno;\
  |  |  129|      0|  }\
  |  |  130|  1.74k|} while (0)
  |  |  ------------------
  |  |  |  Branch (130:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  591|  1.74k|  return n;
  592|  1.74k|}
y.tab.c:list2_gen:
  221|   217k|{
  222|   217k|  return cons(a, cons(b,0));
  ------------------
  |  |  210|   217k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  223|   217k|}
y.tab.c:list3_gen:
  228|   705k|{
  229|   705k|  return cons(a, cons(b, cons(c,0)));
  ------------------
  |  |  210|   705k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  230|   705k|}
y.tab.c:new_colon2:
  685|  3.08k|{
  686|  3.08k|  void_expr_error(p, b);
  687|  3.08k|  return cons((node*)NODE_COLON2, cons(b, nsym(c)));
  ------------------
  |  |  210|  3.08k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  688|  3.08k|}
y.tab.c:call_bin_op:
 1300|   124k|{
 1301|   124k|  return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), '.');
  ------------------
  |  |  146|   124k|#define intern_cstr(s) intern_cstr_gen(p,(s))
  ------------------
                return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), '.');
  ------------------
  |  |  217|   124k|#define list1(a) list1_gen(p, (a))
  ------------------
 1302|   124k|}
y.tab.c:new_hash:
  731|  3.61k|{
  732|  3.61k|  return cons((node*)NODE_HASH, a);
  ------------------
  |  |  210|  3.61k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  733|  3.61k|}
y.tab.c:new_callargs:
  597|   203k|{
  598|   203k|  return cons(a, cons(b, c));
  ------------------
  |  |  210|   203k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  599|   203k|}
y.tab.c:local_var_p:
  343|   580k|{
  344|   580k|  const struct RProc *u;
  345|   580k|  node *l = p->locals;
  346|       |
  347|   907k|  while (l) {
  ------------------
  |  Branch (347:10): [True: 580k, False: 326k]
  ------------------
  348|   580k|    node *n = l->car;
  349|   185M|    while (n) {
  ------------------
  |  Branch (349:12): [True: 184M, False: 326k]
  ------------------
  350|   184M|      if (sym(n->car) == sym) return TRUE;
  ------------------
  |  |  132|   184M|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
                    if (sym(n->car) == sym) return TRUE;
  ------------------
  |  |   54|   253k|#  define TRUE 1
  ------------------
  |  Branch (350:11): [True: 253k, False: 184M]
  ------------------
  351|   184M|      n = n->cdr;
  352|   184M|    }
  353|   326k|    l = l->cdr;
  354|   326k|  }
  355|       |
  356|   326k|  u = p->upper;
  357|   326k|  while (u && !MRB_PROC_CFUNC_P(u)) {
  ------------------
  |  |   65|      0|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  ------------------
  |  Branch (357:10): [True: 0, False: 326k]
  |  Branch (357:15): [True: 0, False: 0]
  ------------------
  358|      0|    const struct mrb_irep *ir = u->body.irep;
  359|      0|    const mrb_sym *v = ir->lv;
  360|      0|    int i;
  361|       |
  362|      0|    if (v) {
  ------------------
  |  Branch (362:9): [True: 0, False: 0]
  ------------------
  363|      0|      for (i=0; i+1 < ir->nlocals; i++) {
  ------------------
  |  Branch (363:17): [True: 0, False: 0]
  ------------------
  364|      0|        if (v[i] == sym) return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (364:13): [True: 0, False: 0]
  ------------------
  365|      0|      }
  366|      0|    }
  367|      0|    if (MRB_PROC_SCOPE_P(u)) break;
  ------------------
  |  |   86|      0|#define MRB_PROC_SCOPE_P(p) (((p)->flags & MRB_PROC_SCOPE) != 0)
  |  |  ------------------
  |  |  |  |   85|      0|#define MRB_PROC_SCOPE 2048
  |  |  ------------------
  |  |  |  Branch (86:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  368|      0|    u = u->upper;
  369|      0|  }
  370|   326k|  return FALSE;
  ------------------
  |  |   51|   326k|#  define FALSE 0
  ------------------
  371|   326k|}
y.tab.c:new_args:
  912|  1.74k|{
  913|  1.74k|  node *n;
  914|       |
  915|  1.74k|  local_add_margs(p, m);
  916|  1.74k|  local_add_margs(p, m2);
  917|  1.74k|  n = cons(m2, tail);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  918|  1.74k|  n = cons(nsym(rest), n);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  919|  1.74k|  n = cons(opt, n);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  920|  1.74k|  while (opt) {
  ------------------
  |  Branch (920:10): [True: 0, False: 1.74k]
  ------------------
  921|       |    /* opt: (sym . (opt . lv)) -> (sym . opt) */
  922|      0|    local_add_lv(p, opt->car->cdr->cdr);
  923|      0|    opt->car->cdr = opt->car->cdr->car;
  924|      0|    opt = opt->cdr;
  925|      0|  }
  926|  1.74k|  return cons(m, n);
  ------------------
  |  |  210|  1.74k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  927|  1.74k|}
y.tab.c:local_add_margs:
  878|  3.49k|{
  879|  3.49k|  while (n) {
  ------------------
  |  Branch (879:10): [True: 0, False: 3.49k]
  ------------------
  880|      0|    if (typen(n->car->car) == NODE_MASGN) {
  ------------------
  |  |  136|      0|#define typen(x) ((enum node_type)(intptr_t)(x))
  ------------------
  |  Branch (880:9): [True: 0, False: 0]
  ------------------
  881|      0|      node *t = n->car->cdr->cdr;
  882|       |
  883|      0|      n->car->cdr->cdr = NULL;
  884|      0|      while (t) {
  ------------------
  |  Branch (884:14): [True: 0, False: 0]
  ------------------
  885|      0|        local_add_f(p, sym(t->car));
  ------------------
  |  |  132|      0|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
  886|      0|        t = t->cdr;
  887|      0|      }
  888|      0|      local_add_margs(p, n->car->cdr->car->car);
  889|      0|      local_add_margs(p, n->car->cdr->car->cdr->cdr->car);
  890|      0|    }
  891|      0|    n = n->cdr;
  892|      0|  }
  893|  3.49k|}
y.tab.c:cons_free_gen:
  168|  3.21M|{
  169|  3.21M|  cons->cdr = p->cells;
  170|  3.21M|  p->cells = cons;
  171|  3.21M|}
y.tab.c:new_str:
 1114|   258k|{
 1115|   258k|  return cons((node*)NODE_STR, cons((node*)strndup(s, len), nint(len)));
  ------------------
  |  |  210|   258k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
 1116|   258k|}
y.tab.c:heredoc_treat_nextline:
 1484|  1.07M|{
 1485|  1.07M|  if (p->heredocs_from_nextline == NULL) return;
  ------------------
  |  Branch (1485:7): [True: 1.07M, False: 0]
  ------------------
 1486|      0|  if (p->parsing_heredoc && p->lex_strterm) {
  ------------------
  |  Branch (1486:7): [True: 0, False: 0]
  |  Branch (1486:29): [True: 0, False: 0]
  ------------------
 1487|      0|    append(p->heredocs_from_nextline, p->parsing_heredoc);
  ------------------
  |  |  267|      0|#define append(a,b) append_gen(p,(a),(b))
  ------------------
 1488|      0|  }
 1489|      0|  p->parsing_heredoc = p->heredocs_from_nextline;
 1490|      0|  p->lex_strterm = new_strterm(p, parsing_heredoc_info(p)->type, 0, 0);
 1491|      0|  p->heredocs_from_nextline = NULL;
 1492|      0|}
y.tab.c:new_ivar:
  775|  31.8k|{
  776|  31.8k|  return cons((node*)NODE_IVAR, nsym(sym));
  ------------------
  |  |  210|  31.8k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  777|  31.8k|}
y.tab.c:new_const:
  796|  43.1k|{
  797|  43.1k|  return cons((node*)NODE_CONST, nsym(sym));
  ------------------
  |  |  210|  43.1k|#define cons(a,b) cons_gen(p,(a),(b))
  ------------------
  798|  43.1k|}
y.tab.c:var_reference:
 1394|   117k|{
 1395|   117k|  node *n;
 1396|       |
 1397|   117k|  if (intn(lhs->car) == NODE_LVAR) {
  ------------------
  |  |  135|   117k|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (1397:7): [True: 74.5k, False: 43.1k]
  ------------------
 1398|  74.5k|    if (!local_var_p(p, sym(lhs->cdr))) {
  ------------------
  |  |  132|  74.5k|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
  |  Branch (1398:9): [True: 1.74k, False: 72.8k]
  ------------------
 1399|  1.74k|      n = new_fcall(p, sym(lhs->cdr), 0);
  ------------------
  |  |  132|  1.74k|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
 1400|  1.74k|      cons_free(lhs);
  ------------------
  |  |  172|  1.74k|#define cons_free(c) cons_free_gen(p, (c))
  ------------------
 1401|  1.74k|      return n;
 1402|  1.74k|    }
 1403|  74.5k|  }
 1404|       |
 1405|   116k|  return lhs;
 1406|   117k|}
y.tab.c:new_int:
 1084|   705k|{
 1085|   705k|  node* result = list3((node*)NODE_INT, (node*)strdup(s), nint(base));
  ------------------
  |  |  231|   705k|#define list3(a,b,c) list3_gen(p, (a),(b),(c))
  ------------------
 1086|   705k|  if (suffix & NUM_SUFFIX_R) {
  ------------------
  |  |  138|   705k|#define NUM_SUFFIX_R   (1<<0)
  ------------------
  |  Branch (1086:7): [True: 0, False: 705k]
  ------------------
 1087|      0|    result = new_rational(p, result);
 1088|      0|  }
 1089|   705k|  if (suffix & NUM_SUFFIX_I) {
  ------------------
  |  |  139|   705k|#define NUM_SUFFIX_I   (1<<1)
  ------------------
  |  Branch (1089:7): [True: 0, False: 705k]
  ------------------
 1090|      0|    result = new_imaginary(p, result);
 1091|      0|  }
 1092|   705k|  return result;
 1093|   705k|}
y.tab.c:locals_node:
  417|  3.49k|{
  418|  3.49k|  return p->locals ? p->locals->car : NULL;
  ------------------
  |  Branch (418:10): [True: 3.49k, False: 0]
  ------------------
  419|  3.49k|}
y.tab.c:yydestruct:
 6204|  3.49k|{
 6205|  3.49k|  YY_USE (yyvaluep);
  ------------------
  |  | 2185|  3.49k|# define YY_USE(E) ((void) (E))
  ------------------
 6206|  3.49k|  YY_USE (p);
  ------------------
  |  | 2185|  3.49k|# define YY_USE(E) ((void) (E))
  ------------------
 6207|  3.49k|  if (!yymsg)
  ------------------
  |  Branch (6207:7): [True: 0, False: 3.49k]
  ------------------
 6208|      0|    yymsg = "Deleting";
 6209|  3.49k|  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
 6210|       |
 6211|  3.49k|  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 6212|  3.49k|  YY_USE (yykind);
  ------------------
  |  | 2185|  3.49k|# define YY_USE(E) ((void) (E))
  ------------------
 6213|  3.49k|  YY_IGNORE_MAYBE_UNINITIALIZED_END
 6214|  3.49k|}
y.tab.c:parser_update_cxt:
13191|  1.73k|{
13192|  1.73k|  node *n, *n0;
13193|  1.73k|  int i = 0;
13194|       |
13195|  1.73k|  if (!cxt) return;
  ------------------
  |  Branch (13195:7): [True: 1.73k, False: 0]
  ------------------
13196|      0|  if (!p->tree) return;
  ------------------
  |  Branch (13196:7): [True: 0, False: 0]
  ------------------
13197|      0|  if (intn(p->tree->car) != NODE_SCOPE) return;
  ------------------
  |  |  135|      0|#define intn(x) ((int)(intptr_t)(x))
  ------------------
  |  Branch (13197:7): [True: 0, False: 0]
  ------------------
13198|      0|  n0 = n = p->tree->cdr->car;
13199|      0|  while (n) {
  ------------------
  |  Branch (13199:10): [True: 0, False: 0]
  ------------------
13200|      0|    i++;
13201|      0|    n = n->cdr;
13202|      0|  }
13203|      0|  cxt->syms = (mrb_sym*)mrb_realloc(p->mrb, cxt->syms, i*sizeof(mrb_sym));
13204|      0|  cxt->slen = i;
13205|      0|  for (i=0, n=n0; n; i++,n=n->cdr) {
  ------------------
  |  Branch (13205:19): [True: 0, False: 0]
  ------------------
13206|      0|    cxt->syms[i] = sym(n->car);
  ------------------
  |  |  132|      0|#define sym(x) ((mrb_sym)(intptr_t)(x))
  ------------------
13207|      0|  }
13208|      0|}
y.tab.c:yyerror:
10743|     40|{
10744|     40|  char* c;
10745|     40|  size_t n;
10746|       |
10747|     40|  if (! p->capture_errors) {
  ------------------
  |  Branch (10747:7): [True: 40, False: 0]
  ------------------
10748|     40|#ifndef MRB_NO_STDIO
10749|     40|    if (p->filename_sym) {
  ------------------
  |  Branch (10749:9): [True: 0, False: 40]
  ------------------
10750|      0|      const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
10751|      0|      fprintf(stderr, "%s:%d:%d: %s\n", filename, p->lineno, p->column, s);
10752|      0|    }
10753|     40|    else {
10754|     40|      fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
10755|     40|    }
10756|     40|#endif
10757|     40|  }
10758|      0|  else if (p->nerr < sizeof(p->error_buffer) / sizeof(p->error_buffer[0])) {
  ------------------
  |  Branch (10758:12): [True: 0, False: 0]
  ------------------
10759|      0|    n = strlen(s);
10760|      0|    c = (char*)parser_palloc(p, n + 1);
10761|      0|    memcpy(c, s, n + 1);
10762|      0|    p->error_buffer[p->nerr].message = c;
10763|      0|    p->error_buffer[p->nerr].lineno = p->lineno;
10764|      0|    p->error_buffer[p->nerr].column = p->column;
10765|      0|  }
10766|     40|  p->nerr++;
10767|     40|}
y.tab.c:parser_palloc:
  176|  8.47M|{
  177|  8.47M|  void *m = mrb_pool_alloc(p->pool, size);
  178|       |
  179|  8.47M|  if (!m) {
  ------------------
  |  Branch (179:7): [True: 0, False: 8.47M]
  ------------------
  180|      0|    MRB_THROW(p->mrb->jmp);
  ------------------
  |  |   48|      0|#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
  |  |  ------------------
  |  |  |  |   41|      0|#define MRB_LONGJMP longjmp
  |  |  ------------------
  ------------------
  181|      0|  }
  182|  8.47M|  return m;
  183|  8.47M|}

mrb_mruby_complex_gem_init:
  394|  1.74k|{
  395|  1.74k|  struct RClass *comp;
  396|       |
  397|  1.74k|  comp = mrb_define_class_id(mrb, MRB_SYM(Complex), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                comp = mrb_define_class_id(mrb, MRB_SYM(Complex), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  398|  1.74k|  MRB_SET_INSTANCE_TT(comp, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  399|       |
  400|  1.74k|  mrb_undef_class_method(mrb, comp, "new");
  401|  1.74k|  mrb_define_class_method(mrb, comp, "rectangular", complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_class_method(mrb, comp, "rectangular", complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  402|  1.74k|  mrb_define_class_method(mrb, comp, "rect", complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_class_method(mrb, comp, "rect", complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  403|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "Complex", complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, mrb->kernel_module, "Complex", complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  404|  1.74k|  mrb_define_method(mrb, comp, "real", complex_real, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  405|  1.74k|  mrb_define_method(mrb, comp, "imaginary", complex_imaginary, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  406|  1.74k|  mrb_define_method(mrb, comp, "to_f", mrb_complex_to_f, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  407|  1.74k|  mrb_define_method(mrb, comp, "to_i", mrb_complex_to_i, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  408|  1.74k|  mrb_define_method(mrb, comp, "to_c", complex_to_c, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  409|  1.74k|  mrb_define_method(mrb, comp, "+", complex_add, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  410|  1.74k|  mrb_define_method(mrb, comp, "-", complex_sub, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  411|  1.74k|  mrb_define_method(mrb, comp, "*", complex_mul, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  412|  1.74k|  mrb_define_method(mrb, comp, "/", complex_div, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  413|  1.74k|  mrb_define_method(mrb, comp, "quo", complex_div, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  414|  1.74k|  mrb_define_method(mrb, comp, "==", complex_eq, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  415|  1.74k|  mrb_define_method(mrb, comp, "hash", complex_hash, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  416|  1.74k|  mrb_define_method(mrb, mrb->nil_class, "to_c", nil_to_c, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  417|  1.74k|}
mrb_mruby_complex_gem_final:
  421|  1.74k|{
  422|  1.74k|}

mrb_mruby_data_gem_init:
  447|  1.74k|{
  448|  1.74k|  struct RClass *d;
  449|  1.74k|  d = mrb_define_class(mrb, "Data",  mrb->object_class);
  450|  1.74k|  MRB_SET_INSTANCE_TT(d, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  451|       |
  452|  1.74k|  mrb_undef_class_method(mrb, d, "new");
  453|  1.74k|  mrb_define_class_method(mrb, d, "define",          mrb_data_s_def,      MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  454|       |
  455|  1.74k|  mrb_define_method(mrb, d,       "==",              mrb_data_equal,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  456|  1.74k|  mrb_define_method(mrb, d,       "members",         mrb_data_members,    MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  457|  1.74k|  mrb_define_method(mrb, d,       "initialize",      mrb_data_initialize, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  458|  1.74k|  mrb_define_method(mrb, d,       "initialize_copy", mrb_data_init_copy,  MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  459|  1.74k|  mrb_define_method(mrb, d,       "eql?",            mrb_data_eql,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  460|       |
  461|  1.74k|  mrb_define_method(mrb, d,       "to_h",            mrb_data_to_h,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  462|  1.74k|  mrb_define_method(mrb, d,       "to_s",            mrb_data_to_s,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  463|  1.74k|  mrb_define_method(mrb, d,       "inspect",         mrb_data_to_s,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  464|  1.74k|}
mrb_mruby_data_gem_final:
  468|  1.74k|{
  469|  1.74k|}

mrb_mruby_dir_gem_init:
  295|  1.74k|{
  296|  1.74k|  struct RClass *d;
  297|       |
  298|  1.74k|  d = mrb_define_class(mrb, "Dir", mrb->object_class);
  299|  1.74k|  MRB_SET_INSTANCE_TT(d, MRB_TT_DATA);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  300|  1.74k|  mrb_define_class_method(mrb, d, "delete", mrb_dir_delete, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  301|  1.74k|  mrb_define_class_method(mrb, d, "exist?", mrb_dir_existp, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  302|  1.74k|  mrb_define_class_method(mrb, d, "getwd",  mrb_dir_getwd,  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  303|  1.74k|  mrb_define_class_method(mrb, d, "mkdir",  mrb_dir_mkdir,  MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_class_method(mrb, d, "mkdir",  mrb_dir_mkdir,  MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  304|  1.74k|  mrb_define_class_method(mrb, d, "_chdir", mrb_dir_chdir,  MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  305|  1.74k|  mrb_define_class_method(mrb, d, "chroot", mrb_dir_chroot, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  306|  1.74k|  mrb_define_class_method(mrb, d, "empty?", mrb_dir_empty, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  307|       |
  308|  1.74k|  mrb_define_method(mrb, d, "close",      mrb_dir_close,  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  309|  1.74k|  mrb_define_method(mrb, d, "initialize", mrb_dir_init,   MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  310|  1.74k|  mrb_define_method(mrb, d, "read",       mrb_dir_read,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  311|  1.74k|  mrb_define_method(mrb, d, "rewind",     mrb_dir_rewind, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  312|  1.74k|  mrb_define_method(mrb, d, "seek",       mrb_dir_seek,   MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  313|  1.74k|  mrb_define_method(mrb, d, "tell",       mrb_dir_tell,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  314|       |
  315|  1.74k|  mrb_define_class(mrb, "IOError", E_STANDARD_ERROR);
  ------------------
  |  | 1373|  1.74k|#define E_STANDARD_ERROR     mrb->eStandardError_class
  ------------------
  316|  1.74k|}
mrb_mruby_dir_gem_final:
  320|  1.74k|{
  321|  1.74k|}

mrb_mruby_errno_gem_init:
  299|  1.74k|{
  300|  1.74k|  struct RClass *e, *eno, *sce;
  301|       |
  302|  1.74k|  sce = mrb_define_class(mrb, "SystemCallError", E_STANDARD_ERROR);
  ------------------
  |  | 1373|  1.74k|#define E_STANDARD_ERROR     mrb->eStandardError_class
  ------------------
  303|  1.74k|  mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  304|  1.74k|  mrb_define_method(mrb, sce, "errno", mrb_sce_errno, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  305|  1.74k|  mrb_define_method(mrb, sce, "initialize", mrb_sce_init_m, MRB_ARGS_ARG(1, 1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  306|       |
  307|  1.74k|  eno = mrb_define_module_id(mrb, MRB_SYM(Errno));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  308|  1.74k|  mrb_define_class_method(mrb, eno, "__errno_defined?", mrb_errno_defined_p, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  309|  1.74k|  mrb_define_class_method(mrb, eno, "__errno_define", mrb_errno_define, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  310|  1.74k|  mrb_define_class_method(mrb, eno, "__errno_list", mrb_errno_list, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  311|       |
  312|  1.74k|  e = mrb_define_class_under_id(mrb, eno, MRB_SYM(NOERROR), sce);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  313|  1.74k|  mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(0));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  314|       |  //mrb_define_method(mrb, e, "===", mrb_exxx_cmp, MRB_ARGS_REQ(1));
  315|       |
  316|       |  // Pre-allocation for Errno::ENOMEM only
  317|  1.74k|  mrb_errno_define_exxx(mrb, MRB_SYM(ENOMEM), ENOMEM);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  318|  1.74k|}
mrb_mruby_errno_gem_final:
  322|  1.74k|{
  323|  1.74k|}
errno.c:mrb_errno_define_exxx:
   56|  1.74k|{
   57|  1.74k|  struct RClass *errno_module = mrb_module_get_id(mrb, MRB_SYM(Errno));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
   58|       |
   59|  1.74k|  if (mrb_const_defined_at(mrb, mrb_obj_value(errno_module), name)) {
  ------------------
  |  Branch (59:7): [True: 0, False: 1.74k]
  ------------------
   60|      0|    mrb_value v = mrb_const_get(mrb, mrb_obj_value(errno_module), name);
   61|       |
   62|      0|    if (mrb_class_p(v)) {
  ------------------
  |  |  193|      0|#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   63|      0|      return mrb_class_ptr(v);
  ------------------
  |  |   24|      0|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   64|      0|    }
   65|      0|  }
   66|       |
   67|  1.74k|  struct RClass *sce_class = mrb_exc_get_id(mrb, MRB_SYM(SystemCallError));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
   68|  1.74k|  struct RClass *e = mrb_define_class_under_id(mrb, errno_module, name, sce_class);
   69|  1.74k|  mrb_define_const_id(mrb, e, MRB_SYM(Errno), mrb_fixnum_value(eno));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
   70|       |
   71|  1.74k|  return e;
   72|  1.74k|}

mrb_mruby_eval_gem_init:
  344|  1.74k|{
  345|  1.74k|  mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  346|  1.74k|  mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), MRB_SYM(instance_eval), f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), MRB_SYM(instance_eval), f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), MRB_SYM(instance_eval), f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), MRB_SYM(instance_eval), f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  347|  1.74k|  mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(module_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(module_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(module_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(module_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  348|  1.74k|  mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(class_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(class_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(class_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
                mrb_define_method_id(mrb, mrb_class_get_id(mrb, MRB_SYM(Module)), MRB_SYM(class_eval), f_class_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  349|       |
  350|  1.74k|  struct RClass *binding = mrb_class_get_id(mrb, MRB_SYM(Binding));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  351|  1.74k|  mrb_define_method(mrb, binding, "eval", mrb_binding_eval, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  352|  1.74k|}
mrb_mruby_eval_gem_final:
  356|  1.74k|{
  357|  1.74k|}

mrb_mruby_fiber_gem_init:
  455|  1.74k|{
  456|  1.74k|  struct RClass *c;
  457|       |
  458|  1.74k|  c = mrb_define_class(mrb, "Fiber", mrb->object_class);
  459|  1.74k|  MRB_SET_INSTANCE_TT(c, MRB_TT_FIBER);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  460|       |
  461|  1.74k|  mrb_define_method(mrb, c, "initialize", fiber_init,    MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
                mrb_define_method(mrb, c, "initialize", fiber_init,    MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  462|  1.74k|  mrb_define_method(mrb, c, "resume",     fiber_resume,  MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  463|  1.74k|  mrb_define_method(mrb, c, "transfer",   fiber_transfer, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  464|  1.74k|  mrb_define_method(mrb, c, "alive?",     fiber_alive_p, MRB_ARGS_NONE());
  ------------------
  |  |  328|  1.74k|#define fiber_alive_p mrb_fiber_alive_p
  ------------------
                mrb_define_method(mrb, c, "alive?",     fiber_alive_p, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  465|  1.74k|  mrb_define_method(mrb, c, "==",         fiber_eq,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  466|       |
  467|  1.74k|  mrb_define_class_method(mrb, c, "yield", fiber_yield, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  468|  1.74k|  mrb_define_class_method(mrb, c, "current", fiber_current, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  469|       |
  470|  1.74k|  mrb_define_class(mrb, "FiberError", E_STANDARD_ERROR);
  ------------------
  |  | 1373|  1.74k|#define E_STANDARD_ERROR     mrb->eStandardError_class
  ------------------
  471|  1.74k|}
mrb_mruby_fiber_gem_final:
  475|  1.74k|{
  476|  1.74k|}

mrb_mruby_hash_ext_gem_init:
  100|  1.74k|{
  101|  1.74k|  struct RClass *h;
  102|       |
  103|  1.74k|  h = mrb->hash_class;
  104|  1.74k|  mrb_define_method(mrb, h, "values_at", hash_values_at, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  105|  1.74k|  mrb_define_method(mrb, h, "slice",     hash_slice, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  106|  1.74k|  mrb_define_method(mrb, h, "except",    hash_except, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  107|  1.74k|}
mrb_mruby_hash_ext_gem_final:
  111|  1.74k|{
  112|  1.74k|}

mrb_init_file:
  644|  1.74k|{
  645|  1.74k|  struct RClass *io, *file, *cnst;
  646|       |
  647|  1.74k|  io   = mrb_class_get_id(mrb, MRB_SYM(IO));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  648|  1.74k|  file = mrb_define_class(mrb, "File", io);
  649|  1.74k|  MRB_SET_INSTANCE_TT(file, MRB_TT_CDATA);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  650|  1.74k|  mrb_define_class_method(mrb, file, "umask",  mrb_file_s_umask, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  651|  1.74k|  mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  652|  1.74k|  mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  653|  1.74k|  mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  654|  1.74k|  mrb_define_class_method(mrb, file, "symlink", mrb_file_s_symlink, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  655|  1.74k|  mrb_define_class_method(mrb, file, "chmod", mrb_file_s_chmod, MRB_ARGS_REQ(1) | MRB_ARGS_REST());
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_class_method(mrb, file, "chmod", mrb_file_s_chmod, MRB_ARGS_REQ(1) | MRB_ARGS_REST());
  ------------------
  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  ------------------
  656|  1.74k|  mrb_define_class_method(mrb, file, "readlink", mrb_file_s_readlink, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  657|       |
  658|  1.74k|  mrb_define_class_method(mrb, file, "dirname",   mrb_file_dirname,    MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  659|  1.74k|  mrb_define_class_method(mrb, file, "basename",  mrb_file_basename,   MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  660|  1.74k|  mrb_define_class_method(mrb, file, "realpath",  mrb_file_realpath,   MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_class_method(mrb, file, "realpath",  mrb_file_realpath,   MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  661|  1.74k|  mrb_define_class_method(mrb, file, "_getwd",    mrb_file__getwd,     MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  662|  1.74k|  mrb_define_class_method(mrb, file, "_gethome",  mrb_file__gethome,   MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  663|       |
  664|  1.74k|  mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  665|  1.74k|  mrb_define_method(mrb, file, "_atime", mrb_file_atime, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  666|  1.74k|  mrb_define_method(mrb, file, "_ctime", mrb_file_ctime, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  667|  1.74k|  mrb_define_method(mrb, file, "_mtime", mrb_file_mtime, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  668|  1.74k|  mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  669|  1.74k|  mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  670|       |
  671|  1.74k|  cnst = mrb_define_module_under_id(mrb, file, MRB_SYM(Constants));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  672|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_SH), mrb_fixnum_value(LOCK_SH));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  673|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_EX), mrb_fixnum_value(LOCK_EX));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  674|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_UN), mrb_fixnum_value(LOCK_UN));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  675|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_NB), mrb_fixnum_value(LOCK_NB));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  676|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR));
  ------------------
  |  |   46|  1.74k|#define FILE_SEPARATOR "/"
  ------------------
  677|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(PATH_SEPARATOR), mrb_str_new_cstr(mrb, PATH_SEPARATOR));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(PATH_SEPARATOR), mrb_str_new_cstr(mrb, PATH_SEPARATOR));
  ------------------
  |  |   53|  1.74k|  #define PATH_SEPARATOR ":"
  ------------------
  678|       |#if defined(_WIN32) || defined(_WIN64)
  679|       |  mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
  680|       |#else
  681|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_nil_value());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  682|  1.74k|#endif
  683|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE));
  ------------------
  |  |   35|  1.74k|  #define NULL_FILE "/dev/null"
  ------------------
  684|       |
  685|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY));
  ------------------
  |  |   46|  1.74k|#define MRB_O_RDONLY            0x0000
  ------------------
  686|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY));
  ------------------
  |  |   47|  1.74k|#define MRB_O_WRONLY            0x0001
  ------------------
  687|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR));
  ------------------
  |  |   48|  1.74k|#define MRB_O_RDWR              0x0002
  ------------------
  688|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND));
  ------------------
  |  |   51|  1.74k|#define MRB_O_APPEND            0x0008
  ------------------
  689|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT));
  ------------------
  |  |   54|  1.74k|#define MRB_O_CREAT             0x0040
  ------------------
  690|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL));
  ------------------
  |  |   56|  1.74k|#define MRB_O_EXCL              0x0100
  ------------------
  691|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC));
  ------------------
  |  |   55|  1.74k|#define MRB_O_TRUNC             0x0080
  ------------------
  692|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK));
  ------------------
  |  |   50|  1.74k|#define MRB_O_NONBLOCK          0x0004
  ------------------
  693|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY));
  ------------------
  |  |   57|  1.74k|#define MRB_O_NOCTTY            0x0200
  ------------------
  694|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY));
  ------------------
  |  |   59|  1.74k|#define MRB_O_BINARY            0x0800
  ------------------
  695|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE));
  ------------------
  |  |   60|  1.74k|#define MRB_O_SHARE_DELETE      0x1000
  ------------------
  696|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC));
  ------------------
  |  |   52|  1.74k|#define MRB_O_SYNC              0x0010
  ------------------
  697|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC));
  ------------------
  |  |   63|  1.74k|#define MRB_O_DSYNC             0x00008000
  ------------------
  698|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC));
  ------------------
  |  |   64|  1.74k|#define MRB_O_RSYNC             0x00010000
  ------------------
  699|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW));
  ------------------
  |  |   53|  1.74k|#define MRB_O_NOFOLLOW          0x0020
  ------------------
  700|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME));
  ------------------
  |  |   62|  1.74k|#define MRB_O_NOATIME           0x4000
  ------------------
  701|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT));
  ------------------
  |  |   58|  1.74k|#define MRB_O_DIRECT            0x0400
  ------------------
  702|  1.74k|  mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE));
  ------------------
  |  |   61|  1.74k|#define MRB_O_TMPFILE           0x2000
  ------------------
  703|  1.74k|}

mrb_init_file_test:
  335|  1.74k|{
  336|  1.74k|  struct RClass *f;
  337|       |
  338|  1.74k|  f = mrb_define_class(mrb, "FileTest", mrb->object_class);
  339|       |
  340|  1.74k|  mrb_define_class_method(mrb, f, "directory?", mrb_filetest_s_directory_p, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  341|  1.74k|  mrb_define_class_method(mrb, f, "exist?",     mrb_filetest_s_exist_p,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  342|  1.74k|  mrb_define_class_method(mrb, f, "exists?",    mrb_filetest_s_exist_p,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  343|  1.74k|  mrb_define_class_method(mrb, f, "file?",      mrb_filetest_s_file_p,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  344|  1.74k|  mrb_define_class_method(mrb, f, "pipe?",      mrb_filetest_s_pipe_p,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  345|  1.74k|  mrb_define_class_method(mrb, f, "size",       mrb_filetest_s_size,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  346|  1.74k|  mrb_define_class_method(mrb, f, "size?",      mrb_filetest_s_size_p,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  347|  1.74k|  mrb_define_class_method(mrb, f, "socket?",    mrb_filetest_s_socket_p,    MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  348|  1.74k|  mrb_define_class_method(mrb, f, "symlink?",   mrb_filetest_s_symlink_p,   MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  349|  1.74k|  mrb_define_class_method(mrb, f, "zero?",      mrb_filetest_s_zero_p,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  350|  1.74k|}

mrb_init_io:
 1914|  1.74k|{
 1915|  1.74k|  struct RClass *io;
 1916|       |
 1917|  1.74k|  io      = mrb_define_class(mrb, "IO", mrb->object_class);
 1918|  1.74k|  MRB_SET_INSTANCE_TT(io, MRB_TT_CDATA);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 1919|       |
 1920|  1.74k|  mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
 1921|  1.74k|  mrb_define_class_method(mrb, io, "_popen",  io_s_popen,   MRB_ARGS_ARG(1,2));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1922|  1.74k|  mrb_define_class_method(mrb, io, "_sysclose",  io_s_sysclose, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1923|  1.74k|  mrb_define_class_method(mrb, io, "for_fd",  io_s_for_fd,   MRB_ARGS_ARG(1,2));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1924|  1.74k|  mrb_define_class_method(mrb, io, "select",  io_s_select,  MRB_ARGS_ARG(1,3));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1925|  1.74k|  mrb_define_class_method(mrb, io, "sysopen", io_s_sysopen, MRB_ARGS_ARG(1,2));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1926|  1.74k|#if !defined(_WIN32) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
 1927|  1.74k|  mrb_define_class_method(mrb, io, "_pipe", io_s_pipe, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1928|  1.74k|#endif
 1929|       |
 1930|  1.74k|  mrb_define_method(mrb, io, "initialize",      io_init, MRB_ARGS_ARG(1,2));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1931|  1.74k|  mrb_define_method(mrb, io, "initialize_copy", io_init_copy, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1932|  1.74k|  mrb_define_method(mrb, io, "isatty",     io_isatty,     MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1933|  1.74k|  mrb_define_method(mrb, io, "eof?",       io_eof,        MRB_ARGS_NONE());   /* 15.2.20.5.6 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1934|  1.74k|  mrb_define_method(mrb, io, "getc",       io_getc,       MRB_ARGS_NONE());   /* 15.2.20.5.8 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1935|  1.74k|  mrb_define_method(mrb, io, "gets",       io_gets,       MRB_ARGS_OPT(2));   /* 15.2.20.5.9 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1936|  1.74k|  mrb_define_method(mrb, io, "read",       io_read,       MRB_ARGS_OPT(2));   /* 15.2.20.5.14 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1937|  1.74k|  mrb_define_method(mrb, io, "readchar",   io_readchar,   MRB_ARGS_NONE());   /* 15.2.20.5.15 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1938|  1.74k|  mrb_define_method(mrb, io, "readline",   io_readline,   MRB_ARGS_OPT(2));   /* 15.2.20.5.16 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1939|  1.74k|  mrb_define_method(mrb, io, "readlines",  io_readlines,  MRB_ARGS_OPT(2));   /* 15.2.20.5.17 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1940|  1.74k|  mrb_define_method(mrb, io, "sync",       io_sync,       MRB_ARGS_NONE());   /* 15.2.20.5.18 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1941|  1.74k|  mrb_define_method(mrb, io, "sync=",      io_set_sync,   MRB_ARGS_REQ(1));   /* 15.2.20.5.19 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1942|  1.74k|  mrb_define_method(mrb, io, "sysread",    io_sysread,    MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1943|  1.74k|  mrb_define_method(mrb, io, "sysseek",    io_sysseek,    MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1944|  1.74k|  mrb_define_method(mrb, io, "syswrite",   io_syswrite,   MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1945|  1.74k|  mrb_define_method(mrb, io, "seek",       io_seek,       MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1946|  1.74k|  mrb_define_method(mrb, io, "close",      io_close,      MRB_ARGS_NONE());   /* 15.2.20.5.1 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1947|  1.74k|  mrb_define_method(mrb, io, "close_write",    io_close_write,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1948|  1.74k|  mrb_define_method(mrb, io, "close_on_exec=", io_set_close_on_exec, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1949|  1.74k|  mrb_define_method(mrb, io, "close_on_exec?", io_close_on_exec_p,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1950|  1.74k|  mrb_define_method(mrb, io, "closed?",    io_closed,     MRB_ARGS_NONE());   /* 15.2.20.5.2 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1951|  1.74k|  mrb_define_method(mrb, io, "flush",      io_flush,      MRB_ARGS_NONE());   /* 15.2.20.5.7 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1952|  1.74k|  mrb_define_method(mrb, io, "ungetc",     io_ungetc,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1953|  1.74k|  mrb_define_method(mrb, io, "pos",        io_pos,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1954|  1.74k|  mrb_define_method(mrb, io, "pid",        io_pid,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1955|  1.74k|  mrb_define_method(mrb, io, "fileno",     io_fileno,     MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1956|  1.74k|  mrb_define_method(mrb, io, "write",      io_write,      MRB_ARGS_ANY());    /* 15.2.20.5.20 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1957|  1.74k|  mrb_define_method(mrb, io, "pread",      io_pread,      MRB_ARGS_ANY());    /* ruby 2.5 feature */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1958|  1.74k|  mrb_define_method(mrb, io, "pwrite",     io_pwrite,     MRB_ARGS_ANY());    /* ruby 2.5 feature */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1959|  1.74k|  mrb_define_method(mrb, io, "getbyte",    io_getbyte,    MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1960|  1.74k|  mrb_define_method(mrb, io, "readbyte",   io_readbyte,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1961|       |
 1962|  1.74k|  mrb_define_const_id(mrb, io, MRB_SYM(SEEK_SET), mrb_fixnum_value(SEEK_SET));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 1963|  1.74k|  mrb_define_const_id(mrb, io, MRB_SYM(SEEK_CUR), mrb_fixnum_value(SEEK_CUR));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 1964|  1.74k|  mrb_define_const_id(mrb, io, MRB_SYM(SEEK_END), mrb_fixnum_value(SEEK_END));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 1965|  1.74k|}
io.c:io_free:
  303|  5.23k|{
  304|  5.23k|  struct mrb_io *io = (struct mrb_io*)ptr;
  305|  5.23k|  if (io != NULL) {
  ------------------
  |  Branch (305:7): [True: 5.23k, False: 0]
  ------------------
  306|  5.23k|    fptr_finalize(mrb, io, TRUE);
  ------------------
  |  |   54|  5.23k|#  define TRUE 1
  ------------------
  307|  5.23k|    mrb_free(mrb, io);
  308|  5.23k|  }
  309|  5.23k|}
io.c:fptr_finalize:
  743|  5.23k|{
  744|  5.23k|  int saved_errno = 0;
  745|  5.23k|  int limit = quiet ? 3 : 0;
  ------------------
  |  Branch (745:15): [True: 5.23k, False: 0]
  ------------------
  746|       |
  747|  5.23k|  if (fptr == NULL) {
  ------------------
  |  Branch (747:7): [True: 0, False: 5.23k]
  ------------------
  748|      0|    return;
  749|      0|  }
  750|       |
  751|  5.23k|  if (fptr->fd >= limit) {
  ------------------
  |  Branch (751:7): [True: 0, False: 5.23k]
  ------------------
  752|       |#ifdef _WIN32
  753|       |    if (fptr->is_socket) {
  754|       |      if (closesocket(fptr->fd) != 0) {
  755|       |        saved_errno = WSAGetLastError();
  756|       |      }
  757|       |      fptr->fd = -1;
  758|       |    }
  759|       |#endif
  760|      0|    if (fptr->fd != -1) {
  ------------------
  |  Branch (760:9): [True: 0, False: 0]
  ------------------
  761|      0|      if (close(fptr->fd) == -1) {
  ------------------
  |  Branch (761:11): [True: 0, False: 0]
  ------------------
  762|      0|        saved_errno = errno;
  763|      0|      }
  764|      0|    }
  765|      0|    fptr->fd = -1;
  766|      0|  }
  767|       |
  768|  5.23k|  if (fptr->fd2 >= limit) {
  ------------------
  |  Branch (768:7): [True: 0, False: 5.23k]
  ------------------
  769|      0|    if (close(fptr->fd2) == -1) {
  ------------------
  |  Branch (769:9): [True: 0, False: 0]
  ------------------
  770|      0|      if (saved_errno == 0) {
  ------------------
  |  Branch (770:11): [True: 0, False: 0]
  ------------------
  771|      0|        saved_errno = errno;
  772|      0|      }
  773|      0|    }
  774|      0|    fptr->fd2 = -1;
  775|      0|  }
  776|       |
  777|  5.23k|#ifndef MRB_NO_IO_POPEN
  778|  5.23k|  if (fptr->pid != 0) {
  ------------------
  |  Branch (778:7): [True: 0, False: 5.23k]
  ------------------
  779|      0|#if !defined(_WIN32) && !defined(_WIN64)
  780|      0|    pid_t pid;
  781|      0|    int status;
  782|      0|    do {
  783|      0|      pid = waitpid(fptr->pid, &status, 0);
  784|      0|    } while (pid == -1 && errno == EINTR);
  ------------------
  |  Branch (784:14): [True: 0, False: 0]
  |  Branch (784:27): [True: 0, False: 0]
  ------------------
  785|      0|    if (!quiet && pid == fptr->pid) {
  ------------------
  |  Branch (785:9): [True: 0, False: 0]
  |  Branch (785:19): [True: 0, False: 0]
  ------------------
  786|      0|      io_set_process_status(mrb, pid, status);
  787|      0|    }
  788|       |#else
  789|       |    HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, fptr->pid);
  790|       |    DWORD status;
  791|       |    if (WaitForSingleObject(h, INFINITE) && GetExitCodeProcess(h, &status))
  792|       |      if (!quiet)
  793|       |        io_set_process_status(mrb, fptr->pid, (int)status);
  794|       |    CloseHandle(h);
  795|       |#endif
  796|      0|    fptr->pid = 0;
  797|       |    /* Note: we don't raise an exception when waitpid(3) fails */
  798|      0|  }
  799|  5.23k|#endif
  800|       |
  801|  5.23k|  if (fptr->buf) {
  ------------------
  |  Branch (801:7): [True: 1.74k, False: 3.49k]
  ------------------
  802|  1.74k|    mrb_free(mrb, fptr->buf);
  803|  1.74k|    fptr->buf = NULL;
  804|  1.74k|  }
  805|       |
  806|  5.23k|  if (!quiet && saved_errno != 0) {
  ------------------
  |  Branch (806:7): [True: 0, False: 5.23k]
  |  Branch (806:17): [True: 0, False: 0]
  ------------------
  807|      0|    errno = saved_errno;
  808|      0|    mrb_sys_fail(mrb, "fptr_finalize failed");
  809|      0|  }
  810|  5.23k|}
io.c:io_mode_to_flags:
  164|  5.23k|{
  165|  5.23k|  if (mrb_nil_p(mode)) {
  ------------------
  |  |  174|  5.23k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 5.23k]
  |  |  ------------------
  ------------------
  166|      0|    return O_RDONLY;
  167|      0|  }
  168|  5.23k|  else if (mrb_string_p(mode)) {
  ------------------
  |  |  187|  5.23k|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|  5.23k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  10.4k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  10.4k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 5.23k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 5.23k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 5.23k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  169|  5.23k|    return io_modestr_to_flags(mrb, RSTRING_CSTR(mrb, mode));
  ------------------
  |  |  105|  5.23k|#define RSTRING_CSTR(mrb,s)  mrb_string_cstr(mrb, s)
  ------------------
  170|  5.23k|  }
  171|      0|  else {
  172|      0|    int flags = 0;
  173|      0|    mrb_int flags0 = mrb_as_int(mrb, mode);
  ------------------
  |  | 1425|      0|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
  174|       |
  175|      0|    switch (flags0 & MRB_O_ACCMODE) {
  ------------------
  |  |   49|      0|#define MRB_O_ACCMODE           (MRB_O_RDONLY | MRB_O_WRONLY | MRB_O_RDWR)
  |  |  ------------------
  |  |  |  |   46|      0|#define MRB_O_RDONLY            0x0000
  |  |  ------------------
  |  |               #define MRB_O_ACCMODE           (MRB_O_RDONLY | MRB_O_WRONLY | MRB_O_RDWR)
  |  |  ------------------
  |  |  |  |   47|      0|#define MRB_O_WRONLY            0x0001
  |  |  ------------------
  |  |               #define MRB_O_ACCMODE           (MRB_O_RDONLY | MRB_O_WRONLY | MRB_O_RDWR)
  |  |  ------------------
  |  |  |  |   48|      0|#define MRB_O_RDWR              0x0002
  |  |  ------------------
  ------------------
  176|      0|      case MRB_O_RDONLY:
  ------------------
  |  |   46|      0|#define MRB_O_RDONLY            0x0000
  ------------------
  |  Branch (176:7): [True: 0, False: 0]
  ------------------
  177|      0|        flags |= O_RDONLY;
  178|      0|        break;
  179|      0|      case MRB_O_WRONLY:
  ------------------
  |  |   47|      0|#define MRB_O_WRONLY            0x0001
  ------------------
  |  Branch (179:7): [True: 0, False: 0]
  ------------------
  180|      0|        flags |= O_WRONLY;
  181|      0|        break;
  182|      0|      case MRB_O_RDWR:
  ------------------
  |  |   48|      0|#define MRB_O_RDWR              0x0002
  ------------------
  |  Branch (182:7): [True: 0, False: 0]
  ------------------
  183|      0|        flags |= O_RDWR;
  184|      0|        break;
  185|      0|      default:
  ------------------
  |  Branch (185:7): [True: 0, False: 0]
  ------------------
  186|      0|        mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %v", mode);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  187|      0|    }
  188|       |
  189|      0|    if (flags0 & MRB_O_APPEND)        flags |= O_APPEND;
  ------------------
  |  |   51|      0|#define MRB_O_APPEND            0x0008
  ------------------
  |  Branch (189:9): [True: 0, False: 0]
  ------------------
  190|      0|    if (flags0 & MRB_O_CREAT)         flags |= O_CREAT;
  ------------------
  |  |   54|      0|#define MRB_O_CREAT             0x0040
  ------------------
  |  Branch (190:9): [True: 0, False: 0]
  ------------------
  191|      0|    if (flags0 & MRB_O_EXCL)          flags |= O_EXCL;
  ------------------
  |  |   56|      0|#define MRB_O_EXCL              0x0100
  ------------------
  |  Branch (191:9): [True: 0, False: 0]
  ------------------
  192|      0|    if (flags0 & MRB_O_TRUNC)         flags |= O_TRUNC;
  ------------------
  |  |   55|      0|#define MRB_O_TRUNC             0x0080
  ------------------
  |  Branch (192:9): [True: 0, False: 0]
  ------------------
  193|      0|#ifdef O_NONBLOCK
  194|      0|    if (flags0 & MRB_O_NONBLOCK)      flags |= O_NONBLOCK;
  ------------------
  |  |   50|      0|#define MRB_O_NONBLOCK          0x0004
  ------------------
  |  Branch (194:9): [True: 0, False: 0]
  ------------------
  195|      0|#endif
  196|      0|#ifdef O_NOCTTY
  197|      0|    if (flags0 & MRB_O_NOCTTY)        flags |= O_NOCTTY;
  ------------------
  |  |   57|      0|#define MRB_O_NOCTTY            0x0200
  ------------------
  |  Branch (197:9): [True: 0, False: 0]
  ------------------
  198|      0|#endif
  199|       |#ifdef O_BINARY
  200|       |    if (flags0 & MRB_O_BINARY)        flags |= O_BINARY;
  201|       |#endif
  202|       |#ifdef O_SHARE_DELETE
  203|       |    if (flags0 & MRB_O_SHARE_DELETE)  flags |= O_SHARE_DELETE;
  204|       |#endif
  205|      0|#ifdef O_SYNC
  206|      0|    if (flags0 & MRB_O_SYNC)          flags |= O_SYNC;
  ------------------
  |  |   52|      0|#define MRB_O_SYNC              0x0010
  ------------------
  |  Branch (206:9): [True: 0, False: 0]
  ------------------
  207|      0|#endif
  208|      0|#ifdef O_DSYNC
  209|      0|    if (flags0 & MRB_O_DSYNC)         flags |= O_DSYNC;
  ------------------
  |  |   63|      0|#define MRB_O_DSYNC             0x00008000
  ------------------
  |  Branch (209:9): [True: 0, False: 0]
  ------------------
  210|      0|#endif
  211|      0|#ifdef O_RSYNC
  212|      0|    if (flags0 & MRB_O_RSYNC)         flags |= O_RSYNC;
  ------------------
  |  |   64|      0|#define MRB_O_RSYNC             0x00010000
  ------------------
  |  Branch (212:9): [True: 0, False: 0]
  ------------------
  213|      0|#endif
  214|      0|#ifdef O_NOFOLLOW
  215|      0|    if (flags0 & MRB_O_NOFOLLOW)      flags |= O_NOFOLLOW;
  ------------------
  |  |   53|      0|#define MRB_O_NOFOLLOW          0x0020
  ------------------
  |  Branch (215:9): [True: 0, False: 0]
  ------------------
  216|      0|#endif
  217|       |#ifdef O_NOATIME
  218|       |    if (flags0 & MRB_O_NOATIME)       flags |= O_NOATIME;
  219|       |#endif
  220|       |#ifdef O_DIRECT
  221|       |    if (flags0 & MRB_O_DIRECT)        flags |= O_DIRECT;
  222|       |#endif
  223|       |#ifdef O_TMPFILE
  224|       |    if (flags0 & MRB_O_TMPFILE)       flags |= O_TMPFILE;
  225|       |#endif
  226|       |
  227|      0|    return flags;
  228|      0|  }
  229|  5.23k|}
io.c:io_modestr_to_flags:
  123|  5.23k|{
  124|  5.23k|  int flags;
  125|  5.23k|  const char *m = mode;
  126|       |
  127|  5.23k|  switch (*m++) {
  128|  1.74k|    case 'r':
  ------------------
  |  Branch (128:5): [True: 1.74k, False: 3.49k]
  ------------------
  129|  1.74k|      flags = O_RDONLY;
  130|  1.74k|      break;
  131|  3.49k|    case 'w':
  ------------------
  |  Branch (131:5): [True: 3.49k, False: 1.74k]
  ------------------
  132|  3.49k|      flags = O_WRONLY | O_CREAT | O_TRUNC;
  133|  3.49k|      break;
  134|      0|    case 'a':
  ------------------
  |  Branch (134:5): [True: 0, False: 5.23k]
  ------------------
  135|      0|      flags = O_WRONLY | O_CREAT | O_APPEND;
  136|      0|      break;
  137|      0|    default:
  ------------------
  |  Branch (137:5): [True: 0, False: 5.23k]
  ------------------
  138|      0|      mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %s", mode);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  139|      0|      flags = 0; /* not reached */
  140|  5.23k|  }
  141|       |
  142|  5.23k|  while (*m) {
  ------------------
  |  Branch (142:10): [True: 0, False: 5.23k]
  ------------------
  143|      0|    switch (*m++) {
  144|      0|      case 'b':
  ------------------
  |  Branch (144:7): [True: 0, False: 0]
  ------------------
  145|       |#ifdef O_BINARY
  146|       |        flags |= O_BINARY;
  147|       |#endif
  148|      0|        break;
  149|      0|      case '+':
  ------------------
  |  Branch (149:7): [True: 0, False: 0]
  ------------------
  150|      0|        flags = (flags & ~OPEN_ACCESS_MODE_FLAGS) | O_RDWR;
  ------------------
  |  |   63|      0|#define OPEN_ACCESS_MODE_FLAGS (O_RDONLY | O_WRONLY | O_RDWR)
  ------------------
  151|      0|        break;
  152|      0|      case ':':
  ------------------
  |  Branch (152:7): [True: 0, False: 0]
  ------------------
  153|       |        /* XXX: PASSTHROUGH*/
  154|      0|      default:
  ------------------
  |  Branch (154:7): [True: 0, False: 0]
  ------------------
  155|      0|        mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %s", mode);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  156|      0|    }
  157|      0|  }
  158|       |
  159|  5.23k|  return flags;
  160|  5.23k|}
io.c:io_alloc:
  323|  5.23k|{
  324|  5.23k|  struct mrb_io *fptr;
  325|       |
  326|  5.23k|  fptr = (struct mrb_io*)mrb_malloc(mrb, sizeof(struct mrb_io));
  327|  5.23k|  fptr->fd = -1;
  328|  5.23k|  fptr->fd2 = -1;
  329|  5.23k|  fptr->pid = 0;
  330|  5.23k|  fptr->buf = 0;
  331|  5.23k|  fptr->readable = 0;
  332|  5.23k|  fptr->writable = 0;
  333|  5.23k|  fptr->sync = 0;
  334|  5.23k|  fptr->eof = 0;
  335|  5.23k|  fptr->is_socket = 0;
  336|  5.23k|  return fptr;
  337|  5.23k|}
io.c:io_buf_init:
  313|  5.23k|{
  314|  5.23k|  if (fptr->readable) {
  ------------------
  |  Branch (314:7): [True: 1.74k, False: 3.49k]
  ------------------
  315|  1.74k|    fptr->buf = (struct mrb_io_buf*)mrb_malloc(mrb, sizeof(struct mrb_io_buf));
  316|  1.74k|    fptr->buf->start = 0;
  317|  1.74k|    fptr->buf->len = 0;
  318|  1.74k|  }
  319|  5.23k|}
io.c:io_init:
  701|  5.23k|{
  702|  5.23k|  struct mrb_io *fptr;
  703|  5.23k|  mrb_int fd;
  704|  5.23k|  mrb_value mode, opt;          /* opt (Hash) will be ignored */
  705|  5.23k|  int flags;
  706|       |
  707|  5.23k|  mode = opt = mrb_nil_value();
  708|       |
  709|  5.23k|  if (mrb_block_given_p(mrb)) {
  ------------------
  |  Branch (709:7): [True: 0, False: 5.23k]
  ------------------
  710|      0|    mrb_warn(mrb, "File.new() does not take block; use File.open() instead");
  711|      0|  }
  712|  5.23k|  mrb_get_args(mrb, "i|oH", &fd, &mode, &opt);
  713|  5.23k|  switch (fd) {
  714|  1.74k|    case 0: /* STDIN_FILENO */
  ------------------
  |  Branch (714:5): [True: 1.74k, False: 3.49k]
  ------------------
  715|  3.49k|    case 1: /* STDOUT_FILENO */
  ------------------
  |  Branch (715:5): [True: 1.74k, False: 3.49k]
  ------------------
  716|  5.23k|    case 2: /* STDERR_FILENO */
  ------------------
  |  Branch (716:5): [True: 1.74k, False: 3.49k]
  ------------------
  717|  5.23k|      break;
  718|      0|    default:
  ------------------
  |  Branch (718:5): [True: 0, False: 5.23k]
  ------------------
  719|      0|      check_file_descriptor(mrb, fd);
  720|      0|      break;
  721|  5.23k|  }
  722|  5.23k|  flags = io_mode_to_flags(mrb, mode);
  723|       |
  724|  5.23k|  fptr = (struct mrb_io*)DATA_PTR(io);
  ------------------
  |  |   50|  5.23k|#define DATA_PTR(d)        (RDATA(d)->data)
  |  |  ------------------
  |  |  |  |   49|  5.23k|#define RDATA(obj)         ((struct RData*)(mrb_ptr(obj)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  5.23k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  725|  5.23k|  if (fptr != NULL) {
  ------------------
  |  Branch (725:7): [True: 0, False: 5.23k]
  ------------------
  726|      0|    fptr_finalize(mrb, fptr, TRUE);
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  727|      0|    mrb_free(mrb, fptr);
  728|      0|  }
  729|  5.23k|  fptr = io_alloc(mrb);
  730|       |
  731|  5.23k|  DATA_TYPE(io) = &mrb_io_type;
  ------------------
  |  |   51|  5.23k|#define DATA_TYPE(d)       (RDATA(d)->type)
  |  |  ------------------
  |  |  |  |   49|  5.23k|#define RDATA(obj)         ((struct RData*)(mrb_ptr(obj)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  5.23k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  732|  5.23k|  DATA_PTR(io) = fptr;
  ------------------
  |  |   50|  5.23k|#define DATA_PTR(d)        (RDATA(d)->data)
  |  |  ------------------
  |  |  |  |   49|  5.23k|#define RDATA(obj)         ((struct RData*)(mrb_ptr(obj)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  5.23k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  733|       |
  734|  5.23k|  fptr->fd = (int)fd;
  735|  5.23k|  fptr->readable = OPEN_READABLE_P(flags);
  ------------------
  |  |   67|  5.23k|#define OPEN_READABLE_P(f)     ((mrb_bool)(OPEN_RDONLY_P(f) || OPEN_RDWR_P(f)))
  |  |  ------------------
  |  |  |  |   64|  10.4k|#define OPEN_RDONLY_P(f)       ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_RDONLY))
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  5.23k|#define OPEN_ACCESS_MODE_FLAGS (O_RDONLY | O_WRONLY | O_RDWR)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (64:32): [True: 1.74k, False: 3.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define OPEN_READABLE_P(f)     ((mrb_bool)(OPEN_RDONLY_P(f) || OPEN_RDWR_P(f)))
  |  |  ------------------
  |  |  |  |   66|  3.49k|#define OPEN_RDWR_P(f)         ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_RDWR))
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  3.49k|#define OPEN_ACCESS_MODE_FLAGS (O_RDONLY | O_WRONLY | O_RDWR)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:32): [True: 0, False: 3.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  736|  5.23k|  fptr->writable = OPEN_WRITABLE_P(flags);
  ------------------
  |  |   68|  5.23k|#define OPEN_WRITABLE_P(f)     ((mrb_bool)(OPEN_WRONLY_P(f) || OPEN_RDWR_P(f)))
  |  |  ------------------
  |  |  |  |   65|  10.4k|#define OPEN_WRONLY_P(f)       ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_WRONLY))
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  5.23k|#define OPEN_ACCESS_MODE_FLAGS (O_RDONLY | O_WRONLY | O_RDWR)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:32): [True: 3.49k, False: 1.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define OPEN_WRITABLE_P(f)     ((mrb_bool)(OPEN_WRONLY_P(f) || OPEN_RDWR_P(f)))
  |  |  ------------------
  |  |  |  |   66|  1.74k|#define OPEN_RDWR_P(f)         ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_RDWR))
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  1.74k|#define OPEN_ACCESS_MODE_FLAGS (O_RDONLY | O_WRONLY | O_RDWR)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:32): [True: 0, False: 1.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  737|  5.23k|  io_buf_init(mrb, fptr);
  738|  5.23k|  return io;
  739|  5.23k|}

mrb_mruby_io_gem_init:
   11|  1.74k|{
   12|  1.74k|  mrb_init_io(mrb); DONE;
  ------------------
  |  |    7|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0)
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   13|  1.74k|  mrb_init_file(mrb); DONE;
  ------------------
  |  |    7|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0)
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   14|  1.74k|  mrb_init_file_test(mrb); DONE;
  ------------------
  |  |    7|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0)
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   15|  1.74k|}
mrb_mruby_io_gem_final:
   19|  1.74k|{
   20|  1.74k|}

mrb_mruby_kernel_ext_gem_init:
  270|  1.74k|{
  271|  1.74k|  struct RClass *krn = mrb->kernel_module;
  272|       |
  273|  1.74k|  mrb_define_module_function(mrb, krn, "fail", mrb_f_raise, MRB_ARGS_OPT(2));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  274|  1.74k|  mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  275|  1.74k|  mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  276|  1.74k|  mrb_define_method(mrb, krn, "__callee__", mrb_f_callee, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  277|  1.74k|  mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  278|  1.74k|#ifndef MRB_NO_FLOAT
  279|  1.74k|  mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  280|  1.74k|#endif
  281|  1.74k|  mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  282|  1.74k|  mrb_define_module_function(mrb, krn, "Array", mrb_f_array, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  283|  1.74k|  mrb_define_module_function(mrb, krn, "Hash", mrb_f_hash, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  284|  1.74k|}
mrb_mruby_kernel_ext_gem_final:
  288|  1.74k|{
  289|  1.74k|}

mrb_mruby_math_gem_init:
  669|  1.74k|{
  670|  1.74k|  struct RClass *mrb_math;
  671|  1.74k|  mrb_math = mrb_define_module(mrb, "Math");
  672|       |
  673|  1.74k|  mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), E_STANDARD_ERROR);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), E_STANDARD_ERROR);
  ------------------
  |  | 1373|  1.74k|#define E_STANDARD_ERROR     mrb->eStandardError_class
  ------------------
  674|       |
  675|  1.74k|#ifdef M_PI
  676|  1.74k|  mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, M_PI));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  677|       |#else
  678|       |  mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, atan(1.0)*4.0));
  679|       |#endif
  680|       |
  681|  1.74k|#ifdef M_E
  682|  1.74k|  mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, M_E));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  683|       |#else
  684|       |  mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, exp(1.0)));
  685|       |#endif
  686|       |
  687|  1.74k|  mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  688|  1.74k|  mrb_define_module_function(mrb, mrb_math, "cos", math_cos, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  689|  1.74k|  mrb_define_module_function(mrb, mrb_math, "tan", math_tan, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  690|       |
  691|  1.74k|  mrb_define_module_function(mrb, mrb_math, "asin", math_asin, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  692|  1.74k|  mrb_define_module_function(mrb, mrb_math, "acos", math_acos, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  693|  1.74k|  mrb_define_module_function(mrb, mrb_math, "atan", math_atan, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  694|  1.74k|  mrb_define_module_function(mrb, mrb_math, "atan2", math_atan2, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  695|       |
  696|  1.74k|  mrb_define_module_function(mrb, mrb_math, "sinh", math_sinh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  697|  1.74k|  mrb_define_module_function(mrb, mrb_math, "cosh", math_cosh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  698|  1.74k|  mrb_define_module_function(mrb, mrb_math, "tanh", math_tanh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  699|       |
  700|  1.74k|  mrb_define_module_function(mrb, mrb_math, "asinh", math_asinh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  701|  1.74k|  mrb_define_module_function(mrb, mrb_math, "acosh", math_acosh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  702|  1.74k|  mrb_define_module_function(mrb, mrb_math, "atanh", math_atanh, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  703|       |
  704|  1.74k|  mrb_define_module_function(mrb, mrb_math, "exp", math_exp, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  705|  1.74k|  mrb_define_module_function(mrb, mrb_math, "log", math_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_module_function(mrb, mrb_math, "log", math_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  706|  1.74k|  mrb_define_module_function(mrb, mrb_math, "log2", math_log2, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  707|  1.74k|  mrb_define_module_function(mrb, mrb_math, "log10", math_log10, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  708|  1.74k|  mrb_define_module_function(mrb, mrb_math, "sqrt", math_sqrt, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  709|  1.74k|  mrb_define_module_function(mrb, mrb_math, "cbrt", math_cbrt, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  710|       |
  711|  1.74k|  mrb_define_module_function(mrb, mrb_math, "frexp", math_frexp, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  712|  1.74k|  mrb_define_module_function(mrb, mrb_math, "ldexp", math_ldexp, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  713|       |
  714|  1.74k|  mrb_define_module_function(mrb, mrb_math, "hypot", math_hypot, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  715|       |
  716|  1.74k|  mrb_define_module_function(mrb, mrb_math, "erf",  math_erf,  MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  717|  1.74k|  mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  718|  1.74k|}
mrb_mruby_math_gem_final:
  722|  1.74k|{
  723|  1.74k|}
math.c:math_sin:
  192|    670|{
  193|    670|  mrb_float x = sin(get_float_arg(mrb));
  ------------------
  |  |  177|    670|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    670|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    670|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  194|    670|  return mrb_float_value(mrb, x);
  195|    670|}
math.c:math_cos:
  206|    282|{
  207|    282|  mrb_float x = cos(get_float_arg(mrb));
  ------------------
  |  |  177|    282|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    282|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    282|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  208|    282|  return mrb_float_value(mrb, x);
  209|    282|}
math.c:math_tan:
  219|    594|{
  220|    594|  mrb_float x = tan(get_float_arg(mrb));
  ------------------
  |  |  177|    594|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    594|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    594|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  221|    594|  return mrb_float_value(mrb, x);
  222|    594|}
math.c:math_log:
  449|  1.53k|{
  450|  1.53k|  mrb_float x, base;
  451|  1.53k|  mrb_int argc;
  452|       |
  453|  1.53k|  argc = mrb_get_args(mrb, "f|f", &x, &base);
  454|  1.53k|  if (x < 0.0) {
  ------------------
  |  Branch (454:7): [True: 0, False: 1.53k]
  ------------------
  455|      0|    domain_error(mrb, "log");
  456|      0|  }
  457|  1.53k|  x = log(x);
  458|  1.53k|  if (argc == 2) {
  ------------------
  |  Branch (458:7): [True: 0, False: 1.53k]
  ------------------
  459|      0|    if (base < 0.0) {
  ------------------
  |  Branch (459:9): [True: 0, False: 0]
  ------------------
  460|      0|      domain_error(mrb, "log");
  461|      0|    }
  462|      0|    x /= log(base);
  463|      0|  }
  464|  1.53k|  return mrb_float_value(mrb, x);
  465|  1.53k|}
math.c:math_log2:
  481|    158|{
  482|    158|  mrb_float x = get_float_arg(mrb);
  ------------------
  |  |  177|    158|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    158|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    158|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  483|       |
  484|    158|  if (x < 0.0) {
  ------------------
  |  Branch (484:7): [True: 0, False: 158]
  ------------------
  485|      0|    domain_error(mrb, "log2");
  486|      0|  }
  487|    158|  x = log2(x);
  488|       |
  489|    158|  return mrb_float_value(mrb, x);
  490|    158|}
math.c:math_log10:
  505|    169|{
  506|    169|  mrb_float x = get_float_arg(mrb);
  ------------------
  |  |  177|    169|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    169|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    169|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  507|       |
  508|    169|  if (x < 0.0) {
  ------------------
  |  Branch (508:7): [True: 0, False: 169]
  ------------------
  509|      0|    domain_error(mrb, "log10");
  510|      0|  }
  511|    169|  x = log10(x);
  512|       |
  513|    169|  return mrb_float_value(mrb, x);
  514|    169|}
math.c:math_sqrt:
  525|    144|{
  526|    144|  mrb_float x = get_float_arg(mrb);
  ------------------
  |  |  177|    144|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    144|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    144|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  527|       |
  528|    144|  if (x < 0.0) {
  ------------------
  |  Branch (528:7): [True: 0, False: 144]
  ------------------
  529|      0|    domain_error(mrb, "sqrt");
  530|      0|  }
  531|    144|  x = sqrt(x);
  532|       |
  533|    144|  return mrb_float_value(mrb, x);
  534|    144|}
math.c:math_cbrt:
  570|  1.68k|{
  571|  1.68k|  mrb_float x = cbrt(get_float_arg(mrb));
  ------------------
  |  |  177|  1.68k|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|  1.68k|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|  1.68k|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  572|  1.68k|  return mrb_float_value(mrb, x);
  573|  1.68k|}
math.c:math_erf:
  647|    623|{
  648|    623|  mrb_float x = erf(get_float_arg(mrb));
  ------------------
  |  |  177|    623|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    623|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    623|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  649|    623|  return mrb_float_value(mrb, x);
  650|    623|}
math.c:math_erfc:
  661|    459|{
  662|    459|  mrb_float x = erfc(get_float_arg(mrb));
  ------------------
  |  |  177|    459|#define get_float_arg(mrb) mrb_as_float((mrb), mrb_get_arg1(mrb))
  |  |  ------------------
  |  |  |  | 1297|    459|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    459|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  663|    459|  return mrb_float_value(mrb, x);
  664|    459|}

mrb_mruby_metaprog_gem_init:
  668|  1.74k|{
  669|  1.74k|  struct RClass *krn = mrb->kernel_module;
  670|  1.74k|  struct RClass *mod = mrb->module_class;
  671|       |
  672|  1.74k|  mrb_define_method(mrb, krn, "global_variables", mrb_f_global_variables, MRB_ARGS_NONE()); /* 15.3.1.3.14 (15.3.1.2.4) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  673|  1.74k|  mrb_define_method(mrb, krn, "local_variables", mrb_local_variables, MRB_ARGS_NONE()); /* 15.3.1.3.28 (15.3.1.2.7) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  674|       |
  675|  1.74k|  mrb_define_method(mrb, krn, "singleton_class", mrb_singleton_class, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  676|  1.74k|  mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined, MRB_ARGS_REQ(1)); /* 15.3.1.3.20 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  677|  1.74k|  mrb_define_method(mrb, krn, "instance_variable_get", mrb_obj_ivar_get, MRB_ARGS_REQ(1)); /* 15.3.1.3.21 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  678|  1.74k|  mrb_define_method(mrb, krn, "instance_variable_set", mrb_obj_ivar_set, MRB_ARGS_REQ(2)); /* 15.3.1.3.22 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  679|  1.74k|  mrb_define_method(mrb, krn, "instance_variables", mrb_obj_instance_variables, MRB_ARGS_NONE()); /* 15.3.1.3.23 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  680|  1.74k|  mrb_define_method(mrb, krn, "methods", mrb_obj_methods_m, MRB_ARGS_OPT(1)); /* 15.3.1.3.31 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  681|  1.74k|  mrb_define_method(mrb, krn, "private_methods", mrb_obj_private_methods, MRB_ARGS_OPT(1)); /* 15.3.1.3.36 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  682|  1.74k|  mrb_define_method(mrb, krn, "protected_methods", mrb_obj_protected_methods, MRB_ARGS_OPT(1)); /* 15.3.1.3.37 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  683|  1.74k|  mrb_define_method(mrb, krn, "public_methods", mrb_obj_public_methods, MRB_ARGS_OPT(1)); /* 15.3.1.3.38 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  684|  1.74k|  mrb_define_method(mrb, krn, "singleton_methods", mrb_obj_singleton_methods_m, MRB_ARGS_OPT(1)); /* 15.3.1.3.45 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  685|  1.74k|  mrb_define_method(mrb, krn, "define_singleton_method", mod_define_singleton_method, MRB_ARGS_REQ(1)|MRB_ARGS_BLOCK());
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, krn, "define_singleton_method", mod_define_singleton_method, MRB_ARGS_REQ(1)|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  686|  1.74k|  mrb_define_method(mrb, krn, "send", mrb_f_send, MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK()); /* 15.3.1.3.44 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, krn, "send", mrb_f_send, MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK()); /* 15.3.1.3.44 */
  ------------------
  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  ------------------
                mrb_define_method(mrb, krn, "send", mrb_f_send, MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK()); /* 15.3.1.3.44 */
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  687|       |
  688|  1.74k|  mrb_define_method(mrb, mod, "class_variables", mrb_mod_class_variables, MRB_ARGS_OPT(1)); /* 15.2.2.4.19 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  689|  1.74k|  mrb_define_method(mrb, mod, "remove_class_variable", mrb_mod_remove_cvar, MRB_ARGS_REQ(1)); /* 15.2.2.4.39 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  690|  1.74k|  mrb_define_method(mrb, mod, "class_variable_defined?", mrb_mod_cvar_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.16 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  691|  1.74k|  mrb_define_method(mrb, mod, "class_variable_get", mrb_mod_cvar_get, MRB_ARGS_REQ(1)); /* 15.2.2.4.17 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  692|  1.74k|  mrb_define_method(mrb, mod, "class_variable_set", mrb_mod_cvar_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.18 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  693|  1.74k|  mrb_define_method(mrb, mod, "included_modules", mrb_mod_included_modules, MRB_ARGS_NONE()); /* 15.2.2.4.30 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  694|  1.74k|  mrb_define_method(mrb, mod, "instance_methods", mrb_mod_instance_methods, MRB_ARGS_ANY()); /* 15.2.2.4.33 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  695|  1.74k|  mrb_define_method(mrb, mod, "undefined_instance_methods", mrb_mod_undefined_methods, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  696|  1.74k|  mrb_define_method(mrb, mod, "remove_method", mrb_mod_remove_method, MRB_ARGS_ANY()); /* 15.2.2.4.41 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  697|  1.74k|  mrb_define_method(mrb, mod, "method_removed", mrb_f_nil, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  698|  1.74k|  mrb_define_method(mrb, mod, "constants", mrb_mod_constants, MRB_ARGS_OPT(1)); /* 15.2.2.4.24 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  699|  1.74k|  mrb_define_class_method(mrb, mod, "constants", mrb_mod_s_constants, MRB_ARGS_ANY()); /* 15.2.2.3.1 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  700|  1.74k|  mrb_define_class_method(mrb, mod, "nesting", mrb_mod_s_nesting, MRB_ARGS_NONE()); /* 15.2.2.3.2 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  701|  1.74k|}
mrb_mruby_metaprog_gem_final:
  705|  1.74k|{
  706|  1.74k|}

mrb_mruby_method_gem_init:
  517|  1.74k|{
  518|  1.74k|  struct RClass *unbound_method = mrb_define_class_id(mrb, MRB_SYM(UnboundMethod), mrb->object_class);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  519|  1.74k|  struct RClass *method = mrb_define_class_id(mrb, MRB_SYM(Method), mrb->object_class);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  520|       |
  521|  1.74k|  MRB_SET_INSTANCE_TT(unbound_method, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  522|  1.74k|  mrb_undef_class_method(mrb, unbound_method, "new");
  523|  1.74k|  mrb_define_method(mrb, unbound_method, "bind", unbound_method_bind, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  524|  1.74k|  mrb_define_method(mrb, unbound_method, "super_method", method_super_method, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  525|  1.74k|  mrb_define_method(mrb, unbound_method, "==", method_eql, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  526|  1.74k|  mrb_define_method(mrb, unbound_method, "eql?", method_eql, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  527|  1.74k|  mrb_define_method(mrb, unbound_method, "to_s", method_to_s, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  528|  1.74k|  mrb_define_method(mrb, unbound_method, "inspect", method_to_s, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  529|  1.74k|  mrb_define_method(mrb, unbound_method, "arity", method_arity, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  530|  1.74k|  mrb_define_method(mrb, unbound_method, "source_location", method_source_location, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  531|  1.74k|  mrb_define_method(mrb, unbound_method, "parameters", method_parameters, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  532|  1.74k|  mrb_define_method(mrb, unbound_method, "bind_call", method_bcall, MRB_ARGS_REQ(1)|MRB_ARGS_ANY());
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, unbound_method, "bind_call", method_bcall, MRB_ARGS_REQ(1)|MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  533|  1.74k|  mrb_define_method(mrb, unbound_method, "owner", method_owner, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  534|  1.74k|  mrb_define_method(mrb, unbound_method, "name", method_name, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  535|       |
  536|  1.74k|  MRB_SET_INSTANCE_TT(method, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  537|  1.74k|  mrb_undef_class_method(mrb, method, "new");
  538|  1.74k|  mrb_define_method(mrb, method, "==", method_eql, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  539|  1.74k|  mrb_define_method(mrb, method, "eql?", method_eql, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  540|  1.74k|  mrb_define_method(mrb, method, "to_s", method_to_s, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  541|  1.74k|  mrb_define_method(mrb, method, "inspect", method_to_s, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  542|  1.74k|  mrb_define_method(mrb, method, "call", method_call, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  543|  1.74k|  mrb_define_method(mrb, method, "[]", method_call, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  544|  1.74k|  mrb_define_method(mrb, method, "unbind", method_unbind, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  545|  1.74k|  mrb_define_method(mrb, method, "super_method", method_super_method, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  546|  1.74k|  mrb_define_method(mrb, method, "arity", method_arity, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  547|  1.74k|  mrb_define_method(mrb, method, "source_location", method_source_location, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  548|  1.74k|  mrb_define_method(mrb, method, "parameters", method_parameters, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  549|  1.74k|  mrb_define_method(mrb, method, "owner", method_owner, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  550|  1.74k|  mrb_define_method(mrb, method, "receiver", method_receiver, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  551|  1.74k|  mrb_define_method(mrb, method, "name", method_name, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  552|       |
  553|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "method", mrb_kernel_method, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  554|       |
  555|  1.74k|  mrb_define_method(mrb, mrb->module_class, "instance_method", mrb_module_instance_method, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  556|  1.74k|}
mrb_mruby_method_gem_final:
  560|  1.74k|{
  561|  1.74k|}

mrb_mruby_numeric_ext_gem_init:
  220|  1.74k|{
  221|  1.74k|  struct RClass *i = mrb->integer_class;
  222|       |
  223|  1.74k|  mrb_define_alias(mrb, i, "modulo", "%");
  224|  1.74k|  mrb_define_method(mrb, i, "remainder", int_remainder, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  225|       |
  226|  1.74k|  mrb_define_method_id(mrb, i, MRB_SYM(pow), int_powm, MRB_ARGS_ARG(1,1));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, i, MRB_SYM(pow), int_powm, MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  227|  1.74k|  mrb_define_method_id(mrb, i, MRB_SYM(digits), int_digits, MRB_ARGS_OPT(1));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method_id(mrb, i, MRB_SYM(digits), int_digits, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  228|       |
  229|  1.74k|#ifndef MRB_NO_FLOAT
  230|  1.74k|  struct RClass *f = mrb->float_class;
  231|       |
  232|  1.74k|  mrb_define_alias(mrb, f, "modulo", "%");
  233|  1.74k|  mrb_define_method(mrb, f, "remainder", flo_remainder, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  234|       |
  235|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX),        mrb_fixnum_value(MRB_FLT_RADIX));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX),        mrb_fixnum_value(MRB_FLT_RADIX));
  ------------------
  |  |  138|  1.74k|# define MRB_FLT_RADIX          FLT_RADIX
  ------------------
  236|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG),     mrb_fixnum_value(MRB_FLT_MANT_DIG));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG),     mrb_fixnum_value(MRB_FLT_MANT_DIG));
  ------------------
  |  |  152|  1.74k|#  define MRB_FLT_MANT_DIG      DBL_MANT_DIG
  ------------------
  237|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON),      mrb_float_value(mrb, MRB_FLT_EPSILON));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON),      mrb_float_value(mrb, MRB_FLT_EPSILON));
  ------------------
  |  |  153|  1.74k|#  define MRB_FLT_EPSILON       DBL_EPSILON
  ------------------
  238|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG),          mrb_fixnum_value(MRB_FLT_DIG));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG),          mrb_fixnum_value(MRB_FLT_DIG));
  ------------------
  |  |  154|  1.74k|#  define MRB_FLT_DIG           DBL_DIG
  ------------------
  239|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP),      mrb_fixnum_value(MRB_FLT_MIN_EXP));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP),      mrb_fixnum_value(MRB_FLT_MIN_EXP));
  ------------------
  |  |  155|  1.74k|#  define MRB_FLT_MIN_EXP       DBL_MIN_EXP
  ------------------
  240|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN),          mrb_float_value(mrb, MRB_FLT_MIN));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN),          mrb_float_value(mrb, MRB_FLT_MIN));
  ------------------
  |  |  156|  1.74k|#  define MRB_FLT_MIN           DBL_MIN
  ------------------
  241|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP),   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP),   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
  ------------------
  |  |  157|  1.74k|#  define MRB_FLT_MIN_10_EXP    DBL_MIN_10_EXP
  ------------------
  242|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP),      mrb_fixnum_value(MRB_FLT_MAX_EXP));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP),      mrb_fixnum_value(MRB_FLT_MAX_EXP));
  ------------------
  |  |  158|  1.74k|#  define MRB_FLT_MAX_EXP       DBL_MAX_EXP
  ------------------
  243|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX),          mrb_float_value(mrb, MRB_FLT_MAX));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX),          mrb_float_value(mrb, MRB_FLT_MAX));
  ------------------
  |  |  159|  1.74k|#  define MRB_FLT_MAX           DBL_MAX
  ------------------
  244|  1.74k|  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP),   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP),   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
  ------------------
  |  |  160|  1.74k|#  define MRB_FLT_MAX_10_EXP    DBL_MAX_10_EXP
  ------------------
  245|  1.74k|#endif /* MRB_NO_FLOAT */
  246|  1.74k|}
mrb_mruby_numeric_ext_gem_final:
  250|  1.74k|{
  251|  1.74k|}

mrb_mruby_object_ext_gem_init:
  115|  1.74k|{
  116|  1.74k|  struct RClass * n = mrb->nil_class;
  117|       |
  118|  1.74k|  mrb_define_method(mrb, n, "to_a", nil_to_a,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  119|  1.74k|#ifndef MRB_NO_FLOAT
  120|  1.74k|  mrb_define_method(mrb, n, "to_f", nil_to_f,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  121|  1.74k|#endif
  122|  1.74k|  mrb_define_method(mrb, n, "to_h", nil_to_h,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  123|  1.74k|  mrb_define_method(mrb, n, "to_i", nil_to_i,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  124|       |
  125|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "itself", f_itself, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  126|       |
  127|  1.74k|  mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
                mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  128|  1.74k|}
mrb_mruby_object_ext_gem_final:
  132|  1.74k|{
  133|  1.74k|}

mrb_mruby_objectspace_gem_init:
  179|  1.74k|{
  180|  1.74k|  struct RClass *os = mrb_define_module(mrb, "ObjectSpace");
  181|  1.74k|  mrb_define_class_method(mrb, os, "count_objects", os_count_objects, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  182|  1.74k|  mrb_define_class_method(mrb, os, "each_object", os_each_object, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  183|  1.74k|}
mrb_mruby_objectspace_gem_final:
  187|  1.74k|{
  188|  1.74k|}
mruby_objectspace.c:os_count_objects:
   60|  15.6k|{
   61|  15.6k|  struct os_count_struct obj_count = { 0 };
   62|  15.6k|  mrb_int i;
   63|  15.6k|  mrb_value hash;
   64|       |
   65|  15.6k|  if (mrb_get_args(mrb, "|H", &hash) == 0) {
  ------------------
  |  Branch (65:7): [True: 12.8k, False: 2.77k]
  ------------------
   66|  12.8k|    hash = mrb_hash_new(mrb);
   67|  12.8k|  }
   68|       |
   69|  15.6k|  if (!mrb_hash_empty_p(mrb, hash)) {
  ------------------
  |  Branch (69:7): [True: 2.77k, False: 12.8k]
  ------------------
   70|  2.77k|    mrb_hash_clear(mrb, hash);
   71|  2.77k|  }
   72|       |
   73|  15.6k|  mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
   74|       |
   75|  15.6k|  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(TOTAL)), mrb_fixnum_value(obj_count.total));
  ------------------
  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
   76|  15.6k|  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(FREE)), mrb_fixnum_value(obj_count.freed));
  ------------------
  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
   77|       |
   78|   453k|  for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
  ------------------
  |  Branch (78:26): [True: 437k, False: 15.6k]
  ------------------
   79|   437k|    mrb_value type;
   80|   437k|    switch (i) {
   81|      0|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
   82|  15.6k|      COUNT_TYPE(T_INTEGER);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   83|  15.6k|      COUNT_TYPE(T_FLOAT);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   84|  15.6k|      COUNT_TYPE(T_CPTR);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   85|  15.6k|      COUNT_TYPE(T_OBJECT);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   86|  15.6k|      COUNT_TYPE(T_CLASS);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   87|  15.6k|      COUNT_TYPE(T_MODULE);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   88|  15.6k|      COUNT_TYPE(T_ICLASS);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   89|  15.6k|      COUNT_TYPE(T_SCLASS);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   90|  15.6k|      COUNT_TYPE(T_PROC);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   91|  15.6k|      COUNT_TYPE(T_ARRAY);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   92|  15.6k|      COUNT_TYPE(T_HASH);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   93|  15.6k|      COUNT_TYPE(T_STRING);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   94|  15.6k|      COUNT_TYPE(T_RANGE);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   95|  15.6k|      COUNT_TYPE(T_EXCEPTION);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   96|  15.6k|      COUNT_TYPE(T_ENV);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   97|  15.6k|      COUNT_TYPE(T_DATA);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   98|  15.6k|      COUNT_TYPE(T_FIBER);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
   99|  15.6k|      COUNT_TYPE(T_STRUCT);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
  100|  15.6k|      COUNT_TYPE(T_ISTRUCT);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
  101|  15.6k|      COUNT_TYPE(T_BREAK);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
  102|  15.6k|      COUNT_TYPE(T_COMPLEX);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
  103|  15.6k|      COUNT_TYPE(T_RATIONAL);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
  104|  15.6k|      COUNT_TYPE(T_BIGINT);
  ------------------
  |  |   81|  15.6k|#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(MRB_SYM(t)); break;
  |  |  ------------------
  |  |  |  |   18|  15.6k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  |  |  |  Branch (81:23): [True: 15.6k, False: 422k]
  |  |  ------------------
  ------------------
  105|      0|#undef COUNT_TYPE
  106|  78.1k|    default:
  ------------------
  |  Branch (106:5): [True: 78.1k, False: 359k]
  ------------------
  107|  78.1k|      type = mrb_fixnum_value(i); break;
  108|   437k|    }
  109|   437k|    if (obj_count.counts[i])
  ------------------
  |  Branch (109:9): [True: 191k, False: 246k]
  ------------------
  110|   191k|      mrb_hash_set(mrb, hash, type, mrb_fixnum_value(obj_count.counts[i]));
  111|   437k|  }
  112|       |
  113|  15.6k|  return hash;
  114|  15.6k|}
mruby_objectspace.c:os_count_object_type:
   23|  16.3M|{
   24|  16.3M|  struct os_count_struct *obj_count;
   25|  16.3M|  obj_count = (struct os_count_struct*)data;
   26|       |
   27|  16.3M|  obj_count->total++;
   28|       |
   29|  16.3M|  if (mrb_object_dead_p(mrb, obj)) {
  ------------------
  |  Branch (29:7): [True: 3.15M, False: 13.1M]
  ------------------
   30|  3.15M|    obj_count->freed++;
   31|  3.15M|  }
   32|  13.1M|  else {
   33|  13.1M|    obj_count->counts[obj->tt]++;
   34|  13.1M|  }
   35|  16.3M|  return MRB_EACH_OBJ_OK;
  ------------------
  |  |   20|  16.3M|#define MRB_EACH_OBJ_OK 0
  ------------------
   36|  16.3M|}

mrb_mruby_pack_gem_init:
 1628|  1.74k|{
 1629|  1.74k|  mrb_define_method(mrb, mrb->array_class, "pack", mrb_pack_pack, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1630|  1.74k|  mrb_define_method(mrb, mrb->string_class, "unpack", mrb_pack_unpack, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1631|  1.74k|  mrb_define_method(mrb, mrb->string_class, "unpack1", mrb_pack_unpack1, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1632|  1.74k|}
mrb_mruby_pack_gem_final:
 1636|  1.74k|{
 1637|  1.74k|}

mrb_mruby_print_gem_init:
   51|  1.74k|{
   52|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "__printstr", mrb_printstr, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
   53|  1.74k|}
mrb_mruby_print_gem_final:
   57|  1.74k|{
   58|  1.74k|}

mrb_mruby_proc_ext_gem_init:
  173|  1.74k|{
  174|  1.74k|  struct RClass *p = mrb->proc_class;
  175|  1.74k|  mrb_define_method(mrb, p, "lambda?",         proc_lambda_p,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  176|  1.74k|  mrb_define_method(mrb, p, "source_location", proc_source_location, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  177|  1.74k|  mrb_define_method(mrb, p, "to_s",            proc_inspect,         MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  178|  1.74k|  mrb_define_method(mrb, p, "inspect",         proc_inspect,         MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  179|  1.74k|  mrb_define_method(mrb, p, "parameters",      mrb_proc_parameters,  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  180|       |
  181|  1.74k|  mrb_define_method(mrb, mrb->kernel_module,   "proc", kernel_proc,  MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
                mrb_define_method(mrb, mrb->kernel_module,   "proc", kernel_proc,  MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  182|  1.74k|}
mrb_mruby_proc_ext_gem_final:
  186|  1.74k|{
  187|  1.74k|}

mrb_mruby_random_gem_init:
  400|  1.74k|{
  401|  1.74k|  struct RClass *random;
  402|  1.74k|  struct RClass *array = mrb->array_class;
  403|       |
  404|  1.74k|  mrb_static_assert(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
  ------------------
  |  |  109|  1.74k|    mrb_static_assert_expand(mrb_static_assert_selector(__VA_ARGS__, mrb_static_assert2, mrb_static_assert1, _)(__VA_ARGS__))
  |  |  ------------------
  |  |  |  |   99|  1.74k|# define mrb_static_assert_expand(...) __VA_ARGS__ /* for MSVC behaviour - https://stackoverflow.com/q/5530505 */
  |  |  ------------------
  ------------------
  405|       |
  406|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "rand", random_f_rand, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  407|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "srand", random_f_srand, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  408|       |
  409|  1.74k|  random = mrb_define_class(mrb, "Random", mrb->object_class);
  410|  1.74k|  mrb_const_set(mrb, mrb_obj_value(mrb->object_class), ID_RANDOM, mrb_obj_value(random)); // for class check
  ------------------
  |  |  158|  1.74k|#define ID_RANDOM MRB_SYM(mruby_Random)
  |  |  ------------------
  |  |  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  ------------------
  411|  1.74k|  MRB_SET_INSTANCE_TT(random, MRB_TT_ISTRUCT);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  412|  1.74k|  mrb_define_class_method(mrb, random, "rand", random_f_rand, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  413|  1.74k|  mrb_define_class_method(mrb, random, "srand", random_f_srand, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  414|  1.74k|  mrb_define_class_method(mrb, random, "bytes", random_f_bytes, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  415|       |
  416|  1.74k|  mrb_define_method(mrb, random, "initialize", random_m_init, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  417|  1.74k|  mrb_define_method(mrb, random, "rand", random_m_rand, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  418|  1.74k|  mrb_define_method(mrb, random, "srand", random_m_srand, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  419|  1.74k|  mrb_define_method(mrb, random, "bytes", random_m_bytes, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  420|       |
  421|  1.74k|  mrb_define_method(mrb, array, "shuffle", mrb_ary_shuffle, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  422|  1.74k|  mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  423|  1.74k|  mrb_define_method(mrb, array, "sample", mrb_ary_sample, MRB_ARGS_OPT(2));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  424|       |
  425|  1.74k|  mrb_value d = mrb_obj_new(mrb, random, 0, NULL);
  426|  1.74k|  rand_state *t = random_ptr(d);
  ------------------
  |  |  171|  1.74k|#define random_ptr(v) (rand_state*)mrb_istruct_ptr(v)
  ------------------
  427|  1.74k|  mrb_iv_set(mrb, mrb_obj_value(random), ID_RANDOM, d);
  ------------------
  |  |  158|  1.74k|#define ID_RANDOM MRB_SYM(mruby_Random)
  |  |  ------------------
  |  |  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  |  |  ------------------
  ------------------
  428|       |
  429|  1.74k|  uint32_t seed = (uint32_t)time(NULL);
  430|  1.74k|  rand_seed(t, seed ^ (uint32_t)(uintptr_t)t);
  431|  1.74k|}
mrb_mruby_random_gem_final:
  434|  1.74k|{
  435|  1.74k|}
random.c:rand_uint32:
   85|  17.4k|{
   86|       |#ifdef XORSHIFT96
   87|       |  uint32_t *seed = state->seed;
   88|       |  uint32_t x = seed[0];
   89|       |  uint32_t y = seed[1];
   90|       |  uint32_t z = seed[2];
   91|       |  uint32_t t;
   92|       |
   93|       |  t = (x ^ (x << 3)) ^ (y ^ (y >> 19)) ^ (z ^ (z << 6));
   94|       |  x = y; y = z; z = t;
   95|       |  seed[0] = x;
   96|       |  seed[1] = y;
   97|       |  seed[2] = z;
   98|       |
   99|       |  return z;
  100|       |#else
  101|  17.4k|  uint32_t *s = state->seed;
  102|  17.4k|  const uint32_t result = rotl(s[0] + s[3], 7) + s[0];
  103|  17.4k|  const uint32_t t = s[1] << 9;
  104|       |
  105|  17.4k|  s[2] ^= s[0];
  106|  17.4k|  s[3] ^= s[1];
  107|  17.4k|  s[1] ^= s[2];
  108|  17.4k|  s[0] ^= s[3];
  109|       |
  110|  17.4k|  s[2] ^= t;
  111|  17.4k|  s[3] = rotl(s[3], 11);
  112|       |
  113|  17.4k|  return result;
  114|  17.4k|#endif  /* XORSHIFT96 */
  115|  17.4k|  }
random.c:rotl:
   78|  34.9k|rotl(const uint32_t x, int k) {
   79|  34.9k|  return (x << k) | (x >> (32 - k));
   80|  34.9k|}
random.c:random_m_init:
  176|  1.74k|{
  177|  1.74k|  mrb_int seed;
  178|  1.74k|  rand_state *t;
  179|       |
  180|  1.74k|  t = random_ptr(self);
  ------------------
  |  |  171|  1.74k|#define random_ptr(v) (rand_state*)mrb_istruct_ptr(v)
  ------------------
  181|  1.74k|  if (mrb_get_args(mrb, "|i", &seed) == 0) {
  ------------------
  |  Branch (181:7): [True: 1.74k, False: 0]
  ------------------
  182|  1.74k|    rand_init(t);
  183|  1.74k|  }
  184|      0|  else {
  185|      0|    rand_seed(t, (uint32_t)seed);
  186|      0|  }
  187|       |
  188|  1.74k|  return self;
  189|  1.74k|}
random.c:rand_init:
   53|  3.49k|{
   54|  3.49k|  t->seed[0] = 123456789;
   55|  3.49k|  t->seed[1] = 362436069;
   56|  3.49k|  t->seed[2] = 521288629;
   57|  3.49k|#ifndef XORSHIFT96
   58|  3.49k|  t->seed[3] = 88675123;
   59|  3.49k|#endif
   60|  3.49k|}
random.c:rand_seed:
   66|  1.74k|{
   67|  1.74k|  uint32_t old_seed = t->seed[SEEDPOS];
  ------------------
  |  |   43|  1.74k|# define SEEDPOS 0
  ------------------
   68|  1.74k|  rand_init(t);
   69|  1.74k|  t->seed[SEEDPOS] = seed;
  ------------------
  |  |   43|  1.74k|# define SEEDPOS 0
  ------------------
   70|  19.1k|  for (int i = 0; i < 10; i++) {
  ------------------
  |  Branch (70:19): [True: 17.4k, False: 1.74k]
  ------------------
   71|  17.4k|    rand_uint32(t);
   72|  17.4k|  }
   73|  1.74k|  return old_seed;
   74|  1.74k|}

mrb_mruby_range_ext_gem_init:
  194|  1.74k|{
  195|  1.74k|  struct RClass * s = mrb->range_class;
  196|       |
  197|  1.74k|  mrb_define_method(mrb, s, "cover?", range_cover, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  198|  1.74k|  mrb_define_method(mrb, s, "size",   range_size,  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  199|  1.74k|}
mrb_mruby_range_ext_gem_final:
  203|  1.74k|{
  204|  1.74k|}

mrb_mruby_rational_gem_init:
  766|  1.74k|{
  767|  1.74k|  struct RClass *rat;
  768|       |
  769|  1.74k|  rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  770|  1.74k|  MRB_SET_INSTANCE_TT(rat, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  771|  1.74k|  mrb_undef_class_method(mrb, rat, "new");
  772|  1.74k|  mrb_define_class_method(mrb, rat, "_new", rational_s_new, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  773|  1.74k|  mrb_define_method(mrb, rat, "numerator", rational_numerator, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  774|  1.74k|  mrb_define_method(mrb, rat, "denominator", rational_denominator, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  775|  1.74k|#ifndef MRB_NO_FLOAT
  776|  1.74k|  mrb_define_method(mrb, rat, "to_f", mrb_rational_to_f, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  777|  1.74k|#endif
  778|  1.74k|  mrb_define_method(mrb, rat, "to_i", mrb_rational_to_i, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  779|  1.74k|  mrb_define_method(mrb, rat, "to_r", rational_to_r, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  780|  1.74k|  mrb_define_method(mrb, rat, "negative?", rational_negative_p, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  781|  1.74k|  mrb_define_method(mrb, rat, "==", rational_eq, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  782|  1.74k|  mrb_define_method(mrb, rat, "<=>", rational_cmp, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  783|  1.74k|  mrb_define_method(mrb, rat, "-@", rational_minus, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  784|  1.74k|  mrb_define_method(mrb, rat, "+", rational_add, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  785|  1.74k|  mrb_define_method(mrb, rat, "-", rational_sub, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  786|  1.74k|  mrb_define_method(mrb, rat, "*", rational_mul, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  787|  1.74k|  mrb_define_method(mrb, rat, "/", rational_div, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  788|  1.74k|  mrb_define_method(mrb, rat, "quo", rational_div, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  789|  1.74k|  mrb_define_method(mrb, rat, "**", rational_pow, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  790|  1.74k|  mrb_define_method(mrb, rat, "hash", rational_hash, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  791|  1.74k|#ifndef MRB_NO_FLOAT
  792|  1.74k|  mrb_define_method(mrb, mrb->float_class, "to_r", float_to_r, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  793|  1.74k|#endif
  794|  1.74k|  mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  795|  1.74k|  mrb_define_method(mrb, mrb->nil_class, "to_r", nil_to_r, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  796|  1.74k|  mrb_define_method(mrb, mrb->kernel_module, "Rational", rational_m, MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  797|  1.74k|}
mrb_mruby_rational_gem_final:
  801|  1.74k|{
  802|  1.74k|}

mrb_mruby_socket_gem_init:
  859|  1.74k|{
  860|  1.74k|  struct RClass *io, *ai, *sock, *bsock, *ipsock, *tcpsock;
  861|  1.74k|  struct RClass *constants;
  862|       |
  863|       |#ifdef _WIN32
  864|       |  WSADATA wsaData;
  865|       |  int result;
  866|       |  result = WSAStartup(MAKEWORD(2,2), &wsaData);
  867|       |  if (result != NO_ERROR)
  868|       |    mrb_raise(mrb, E_RUNTIME_ERROR, "WSAStartup failed");
  869|       |#endif
  870|       |
  871|  1.74k|  ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
  872|  1.74k|  mrb_mod_cv_set(mrb, ai, MRB_SYM(_lastai), mrb_nil_value());
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  873|  1.74k|  mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  874|  1.74k|  mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  875|  1.74k|#ifndef _WIN32
  876|  1.74k|  mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  877|  1.74k|#endif
  878|       |
  879|  1.74k|  io = mrb_class_get_id(mrb, MRB_SYM(IO));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  880|       |
  881|  1.74k|  bsock = mrb_define_class(mrb, "BasicSocket", io);
  882|  1.74k|  mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  883|  1.74k|  mrb_define_method(mrb, bsock, "_setnonblock", mrb_basicsocket_setnonblock, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  884|  1.74k|  mrb_define_method(mrb, bsock, "getpeereid", mrb_basicsocket_getpeereid, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  885|  1.74k|  mrb_define_method(mrb, bsock, "getpeername", mrb_basicsocket_getpeername, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  886|  1.74k|  mrb_define_method(mrb, bsock, "getsockname", mrb_basicsocket_getsockname, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  887|  1.74k|  mrb_define_method(mrb, bsock, "getsockopt", mrb_basicsocket_getsockopt, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  888|  1.74k|  mrb_define_method(mrb, bsock, "recv", mrb_basicsocket_recv, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, bsock, "recv", mrb_basicsocket_recv, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  889|       |  // #recvmsg(maxlen, flags=0)
  890|  1.74k|  mrb_define_method(mrb, bsock, "send", mrb_basicsocket_send, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, bsock, "send", mrb_basicsocket_send, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  891|       |  // #sendmsg
  892|       |  // #sendmsg_nonblock
  893|  1.74k|  mrb_define_method(mrb, bsock, "setsockopt", mrb_basicsocket_setsockopt, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, bsock, "setsockopt", mrb_basicsocket_setsockopt, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(2));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  894|  1.74k|  mrb_define_method(mrb, bsock, "shutdown", mrb_basicsocket_shutdown, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  895|  1.74k|  mrb_define_method(mrb, bsock, "_is_socket=", mrb_basicsocket_set_is_socket, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  896|       |
  897|  1.74k|  ipsock = mrb_define_class(mrb, "IPSocket", bsock);
  898|  1.74k|  mrb_define_class_method(mrb, ipsock, "ntop", mrb_ipsocket_ntop, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  899|  1.74k|  mrb_define_class_method(mrb, ipsock, "pton", mrb_ipsocket_pton, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  900|  1.74k|  mrb_define_method(mrb, ipsock, "recvfrom", mrb_ipsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, ipsock, "recvfrom", mrb_ipsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  901|       |
  902|  1.74k|  tcpsock = mrb_define_class(mrb, "TCPSocket", ipsock);
  903|  1.74k|  mrb_define_class_method(mrb, tcpsock, "_allocate", mrb_tcpsocket_allocate, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  904|  1.74k|  mrb_define_class(mrb, "TCPServer", tcpsock);
  905|       |
  906|  1.74k|  mrb_define_class(mrb, "UDPSocket", ipsock);
  907|       |  //#recvfrom_nonblock
  908|       |
  909|  1.74k|  sock = mrb_define_class(mrb, "Socket", bsock);
  910|  1.74k|  mrb_define_class_method(mrb, sock, "_accept", mrb_socket_accept, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  911|  1.74k|  mrb_define_class_method(mrb, sock, "_accept2", mrb_socket_accept2, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  912|  1.74k|  mrb_define_class_method(mrb, sock, "_bind", mrb_socket_bind, MRB_ARGS_REQ(3));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  913|  1.74k|  mrb_define_class_method(mrb, sock, "_connect", mrb_socket_connect, MRB_ARGS_REQ(3));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  914|  1.74k|  mrb_define_class_method(mrb, sock, "_listen", mrb_socket_listen, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  915|  1.74k|  mrb_define_class_method(mrb, sock, "_sockaddr_family", mrb_socket_sockaddr_family, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  916|  1.74k|  mrb_define_class_method(mrb, sock, "_socket", mrb_socket_socket, MRB_ARGS_REQ(3));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  917|       |  //mrb_define_class_method(mrb, sock, "gethostbyaddr", mrb_socket_gethostbyaddr, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  918|       |  //mrb_define_class_method(mrb, sock, "gethostbyname", mrb_socket_gethostbyname, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  919|  1.74k|  mrb_define_class_method(mrb, sock, "gethostname", mrb_socket_gethostname, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  920|       |  //mrb_define_class_method(mrb, sock, "getservbyname", mrb_socket_getservbyname, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  921|       |  //mrb_define_class_method(mrb, sock, "getservbyport", mrb_socket_getservbyport, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  922|  1.74k|  mrb_define_class_method(mrb, sock, "sockaddr_un", mrb_socket_sockaddr_un, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  923|  1.74k|  mrb_define_class_method(mrb, sock, "socketpair", mrb_socket_socketpair, MRB_ARGS_REQ(3));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  924|       |  //mrb_define_method(mrb, sock, "sysaccept", mrb_socket_accept, MRB_ARGS_NONE());
  925|       |
  926|  1.74k|#ifndef _WIN32
  927|  1.74k|  mrb_define_class(mrb, "UNIXSocket", bsock);
  928|       |  //mrb_define_class_method(mrb, usock, "pair", mrb_unixsocket_open, MRB_ARGS_OPT(2));
  929|       |  //mrb_define_class_method(mrb, usock, "socketpair", mrb_unixsocket_open, MRB_ARGS_OPT(2));
  930|       |
  931|       |  //mrb_define_method(mrb, usock, "recv_io", mrb_unixsocket_peeraddr, MRB_ARGS_NONE());
  932|       |  //mrb_define_method(mrb, usock, "recvfrom", mrb_unixsocket_peeraddr, MRB_ARGS_NONE());
  933|       |  //mrb_define_method(mrb, usock, "send_io", mrb_unixsocket_peeraddr, MRB_ARGS_NONE());
  934|  1.74k|#endif
  935|       |
  936|       |  /* Windows IO Method Overrides on BasicSocket */
  937|       |#ifdef _WIN32
  938|       |  mrb_define_method(mrb, bsock, "close", mrb_win32_basicsocket_close, MRB_ARGS_NONE());
  939|       |  mrb_define_method(mrb, bsock, "sysread", mrb_win32_basicsocket_sysread, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  940|       |  mrb_define_method(mrb, bsock, "sysseek", mrb_win32_basicsocket_sysseek, MRB_ARGS_REQ(1));
  941|       |  mrb_define_method(mrb, bsock, "syswrite", mrb_win32_basicsocket_syswrite, MRB_ARGS_REQ(1));
  942|       |  mrb_define_method(mrb, bsock, "read", mrb_win32_basicsocket_sysread, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
  943|       |  mrb_define_method(mrb, bsock, "write", mrb_win32_basicsocket_syswrite, MRB_ARGS_REQ(1));
  944|       |#endif
  945|       |
  946|  1.74k|  constants = mrb_define_module_under(mrb, sock, "Constants");
  947|       |
  948|  1.74k|#define define_const(SYM) \
  949|  1.74k|  do {                                                                \
  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  951|  1.74k|  } while (0)
  952|       |
  953|  1.74k|#include "const.cstub"
  ------------------
  |  |    1|  1.74k|#if defined(AF_INET)
  |  |    2|  1.74k|  define_const(AF_INET);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |    3|  1.74k|#endif
  |  |    4|  1.74k|#if defined(PF_INET)
  |  |    5|  1.74k|  define_const(PF_INET);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |    6|  1.74k|#endif
  |  |    7|  1.74k|#if defined(AF_INET6)
  |  |    8|  1.74k|  define_const(AF_INET6);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |    9|  1.74k|#endif
  |  |   10|  1.74k|#if defined(PF_INET6)
  |  |   11|  1.74k|  define_const(PF_INET6);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   12|  1.74k|#endif
  |  |   13|       |#if defined(AF_LINK)
  |  |   14|       |  define_const(AF_LINK);
  |  |   15|       |#endif
  |  |   16|       |#if defined(PF_LINK)
  |  |   17|       |  define_const(PF_LINK);
  |  |   18|       |#endif
  |  |   19|  1.74k|#if defined(AF_LOCAL)
  |  |   20|  1.74k|  define_const(AF_LOCAL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|  1.74k|#endif
  |  |   22|  1.74k|#if defined(PF_LOCAL)
  |  |   23|  1.74k|  define_const(PF_LOCAL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|  1.74k|#endif
  |  |   25|  1.74k|#if defined(AF_UNIX)
  |  |   26|  1.74k|  define_const(AF_UNIX);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|  1.74k|#endif
  |  |   28|  1.74k|#if defined(PF_UNIX)
  |  |   29|  1.74k|  define_const(PF_UNIX);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|  1.74k|#endif
  |  |   31|  1.74k|#if defined(AF_MAX)
  |  |   32|  1.74k|  define_const(AF_MAX);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|  1.74k|#endif
  |  |   34|  1.74k|#if defined(AF_UNSPEC)
  |  |   35|  1.74k|  define_const(AF_UNSPEC);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|  1.74k|#endif
  |  |   37|  1.74k|#if defined(PF_UNSPEC)
  |  |   38|  1.74k|  define_const(PF_UNSPEC);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|  1.74k|#endif
  |  |   40|  1.74k|#if defined(AF_ROUTE)
  |  |   41|  1.74k|  define_const(AF_ROUTE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|  1.74k|#endif
  |  |   43|  1.74k|#if defined(PF_ROUTE)
  |  |   44|  1.74k|  define_const(PF_ROUTE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|  1.74k|#endif
  |  |   46|  1.74k|#if defined(AI_CANONNAME)
  |  |   47|  1.74k|  define_const(AI_CANONNAME);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|  1.74k|#endif
  |  |   49|       |#if defined(AI_FQDN)
  |  |   50|       |  define_const(AI_FQDN);
  |  |   51|       |#endif
  |  |   52|  1.74k|#if defined(AI_NUMERICHOST)
  |  |   53|  1.74k|  define_const(AI_NUMERICHOST);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  1.74k|#endif
  |  |   55|  1.74k|#if defined(AI_NUMERICSERV)
  |  |   56|  1.74k|  define_const(AI_NUMERICSERV);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|  1.74k|#endif
  |  |   58|  1.74k|#if defined(AI_PASSIVE)
  |  |   59|  1.74k|  define_const(AI_PASSIVE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|  1.74k|#endif
  |  |   61|  1.74k|#if defined(IP_ADD_MEMBERSHIP)
  |  |   62|  1.74k|  define_const(IP_ADD_MEMBERSHIP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|  1.74k|#endif
  |  |   64|  1.74k|#if defined(IP_ADD_SOURCE_MEMBERSHIP)
  |  |   65|  1.74k|  define_const(IP_ADD_SOURCE_MEMBERSHIP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|  1.74k|#endif
  |  |   67|  1.74k|#if defined(IP_BLOCK_SOURCE)
  |  |   68|  1.74k|  define_const(IP_BLOCK_SOURCE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|  1.74k|#endif
  |  |   70|  1.74k|#if defined(IP_DROP_MEMBERSHIP)
  |  |   71|  1.74k|  define_const(IP_DROP_MEMBERSHIP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|  1.74k|#endif
  |  |   73|  1.74k|#if defined(IP_DROP_SOURCE_MEMBERSHIP)
  |  |   74|  1.74k|  define_const(IP_DROP_SOURCE_MEMBERSHIP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|  1.74k|#endif
  |  |   76|  1.74k|#if defined(IP_FREEBIND)
  |  |   77|  1.74k|  define_const(IP_FREEBIND);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|  1.74k|#endif
  |  |   79|  1.74k|#if defined(IP_HDRINCL)
  |  |   80|  1.74k|  define_const(IP_HDRINCL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|  1.74k|#endif
  |  |   82|  1.74k|#if defined(IP_IPSEC_POLICY)
  |  |   83|  1.74k|  define_const(IP_IPSEC_POLICY);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|  1.74k|#endif
  |  |   85|  1.74k|#if defined(IP_MINTTL)
  |  |   86|  1.74k|  define_const(IP_MINTTL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|  1.74k|#endif
  |  |   88|  1.74k|#if defined(IP_MSFILTER)
  |  |   89|  1.74k|  define_const(IP_MSFILTER);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|  1.74k|#endif
  |  |   91|  1.74k|#if defined(IP_MTU)
  |  |   92|  1.74k|  define_const(IP_MTU);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|  1.74k|#endif
  |  |   94|  1.74k|#if defined(IP_MTU_DISCOVER)
  |  |   95|  1.74k|  define_const(IP_MTU_DISCOVER);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|  1.74k|#endif
  |  |   97|  1.74k|#if defined(IP_MULTICAST_ALL)
  |  |   98|  1.74k|  define_const(IP_MULTICAST_ALL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|  1.74k|#endif
  |  |  100|  1.74k|#if defined(IP_MULTICAST_IF)
  |  |  101|  1.74k|  define_const(IP_MULTICAST_IF);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|  1.74k|#endif
  |  |  103|  1.74k|#if defined(IP_MULTICAST_LOOP)
  |  |  104|  1.74k|  define_const(IP_MULTICAST_LOOP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|  1.74k|#endif
  |  |  106|  1.74k|#if defined(IP_MULTICAST_TTL)
  |  |  107|  1.74k|  define_const(IP_MULTICAST_TTL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|  1.74k|#endif
  |  |  109|  1.74k|#if defined(IP_OPTIONS)
  |  |  110|  1.74k|  define_const(IP_OPTIONS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|  1.74k|#endif
  |  |  112|  1.74k|#if defined(IP_ORIGDSTADDR)
  |  |  113|  1.74k|  define_const(IP_ORIGDSTADDR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|  1.74k|#endif
  |  |  115|  1.74k|#if defined(IP_PASSSEC)
  |  |  116|  1.74k|  define_const(IP_PASSSEC);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|  1.74k|#endif
  |  |  118|  1.74k|#if defined(IP_PKTINFO)
  |  |  119|  1.74k|  define_const(IP_PKTINFO);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|  1.74k|#endif
  |  |  121|  1.74k|#if defined(IP_PKTOPTIONS)
  |  |  122|  1.74k|  define_const(IP_PKTOPTIONS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  123|  1.74k|#endif
  |  |  124|  1.74k|#if defined(IP_PMTUDISC_DO)
  |  |  125|  1.74k|  define_const(IP_PMTUDISC_DO);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  126|  1.74k|#endif
  |  |  127|  1.74k|#if defined(IP_PMTUDISC_DONT)
  |  |  128|  1.74k|  define_const(IP_PMTUDISC_DONT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  129|  1.74k|#endif
  |  |  130|  1.74k|#if defined(IP_PMTUDISC_PROBE)
  |  |  131|  1.74k|  define_const(IP_PMTUDISC_PROBE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  132|  1.74k|#endif
  |  |  133|  1.74k|#if defined(IP_PMTUDISC_WANT)
  |  |  134|  1.74k|  define_const(IP_PMTUDISC_WANT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  135|  1.74k|#endif
  |  |  136|       |#if defined(IP_RECVDSTADDR)
  |  |  137|       |  define_const(IP_RECVDSTADDR);
  |  |  138|       |#endif
  |  |  139|  1.74k|#if defined(IP_RECVERR)
  |  |  140|  1.74k|  define_const(IP_RECVERR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  141|  1.74k|#endif
  |  |  142|  1.74k|#if defined(IP_RECVOPTS)
  |  |  143|  1.74k|  define_const(IP_RECVOPTS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  144|  1.74k|#endif
  |  |  145|  1.74k|#if defined(IP_RECVORIGDSTADDR)
  |  |  146|  1.74k|  define_const(IP_RECVORIGDSTADDR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  147|  1.74k|#endif
  |  |  148|  1.74k|#if defined(IP_RECVRETOPTS)
  |  |  149|  1.74k|  define_const(IP_RECVRETOPTS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  150|  1.74k|#endif
  |  |  151|  1.74k|#if defined(IP_RECVTOS)
  |  |  152|  1.74k|  define_const(IP_RECVTOS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  153|  1.74k|#endif
  |  |  154|  1.74k|#if defined(IP_RECVTTL)
  |  |  155|  1.74k|  define_const(IP_RECVTTL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  156|  1.74k|#endif
  |  |  157|  1.74k|#if defined(IP_RETOPTS)
  |  |  158|  1.74k|  define_const(IP_RETOPTS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  159|  1.74k|#endif
  |  |  160|  1.74k|#if defined(IP_ROUTER_ALERT)
  |  |  161|  1.74k|  define_const(IP_ROUTER_ALERT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  162|  1.74k|#endif
  |  |  163|  1.74k|#if defined(IP_TOS)
  |  |  164|  1.74k|  define_const(IP_TOS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  165|  1.74k|#endif
  |  |  166|  1.74k|#if defined(IP_TRANSPARENT)
  |  |  167|  1.74k|  define_const(IP_TRANSPARENT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  168|  1.74k|#endif
  |  |  169|  1.74k|#if defined(IP_TTL)
  |  |  170|  1.74k|  define_const(IP_TTL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  171|  1.74k|#endif
  |  |  172|  1.74k|#if defined(IP_UNBLOCK_SOURCE)
  |  |  173|  1.74k|  define_const(IP_UNBLOCK_SOURCE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  174|  1.74k|#endif
  |  |  175|  1.74k|#if defined(IP_XFRM_POLICY)
  |  |  176|  1.74k|  define_const(IP_XFRM_POLICY);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  177|  1.74k|#endif
  |  |  178|  1.74k|#if defined(IPV6_JOIN_GROUP)
  |  |  179|  1.74k|  define_const(IPV6_JOIN_GROUP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  180|  1.74k|#endif
  |  |  181|  1.74k|#if defined(IPV6_LEAVE_GROUP)
  |  |  182|  1.74k|  define_const(IPV6_LEAVE_GROUP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  183|  1.74k|#endif
  |  |  184|  1.74k|#if defined(IPV6_MULTICAST_HOPS)
  |  |  185|  1.74k|  define_const(IPV6_MULTICAST_HOPS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  186|  1.74k|#endif
  |  |  187|  1.74k|#if defined(IPV6_MULTICAST_IF)
  |  |  188|  1.74k|  define_const(IPV6_MULTICAST_IF);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  189|  1.74k|#endif
  |  |  190|  1.74k|#if defined(IPV6_MULTICAST_LOOP)
  |  |  191|  1.74k|  define_const(IPV6_MULTICAST_LOOP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  192|  1.74k|#endif
  |  |  193|  1.74k|#if defined(IPV6_UNICAST_HOPS)
  |  |  194|  1.74k|  define_const(IPV6_UNICAST_HOPS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  195|  1.74k|#endif
  |  |  196|  1.74k|#if defined(IPV6_V6ONLY)
  |  |  197|  1.74k|  define_const(IPV6_V6ONLY);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  198|  1.74k|#endif
  |  |  199|  1.74k|#if defined(IPPROTO_AH) || defined(_WINSOCKAPI_)
  |  |  200|  1.74k|  define_const(IPPROTO_AH);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  201|  1.74k|#endif
  |  |  202|  1.74k|#if defined(IPPROTO_DSTOPTS) || defined(_WINSOCKAPI_)
  |  |  203|  1.74k|  define_const(IPPROTO_DSTOPTS);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  204|  1.74k|#endif
  |  |  205|  1.74k|#if defined(IPPROTO_ESP) || defined(_WINSOCKAPI_)
  |  |  206|  1.74k|  define_const(IPPROTO_ESP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  207|  1.74k|#endif
  |  |  208|  1.74k|#if defined(IPPROTO_FRAGMENT) || defined(_WINSOCKAPI_)
  |  |  209|  1.74k|  define_const(IPPROTO_FRAGMENT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  210|  1.74k|#endif
  |  |  211|  1.74k|#if defined(IPPROTO_ICMP) || defined(_WINSOCKAPI_)
  |  |  212|  1.74k|  define_const(IPPROTO_ICMP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  213|  1.74k|#endif
  |  |  214|  1.74k|#if defined(IPPROTO_ICMPV6) || defined(_WINSOCKAPI_)
  |  |  215|  1.74k|  define_const(IPPROTO_ICMPV6);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  216|  1.74k|#endif
  |  |  217|  1.74k|#if defined(IPPROTO_IP) || defined(_WINSOCKAPI_)
  |  |  218|  1.74k|  define_const(IPPROTO_IP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  219|  1.74k|#endif
  |  |  220|  1.74k|#if defined(IPPROTO_IPV6) || defined(_WINSOCKAPI_)
  |  |  221|  1.74k|  define_const(IPPROTO_IPV6);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  222|  1.74k|#endif
  |  |  223|  1.74k|#if defined(IPPROTO_NONE) || defined(_WINSOCKAPI_)
  |  |  224|  1.74k|  define_const(IPPROTO_NONE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  225|  1.74k|#endif
  |  |  226|  1.74k|#if defined(IPPROTO_RAW) || defined(_WINSOCKAPI_)
  |  |  227|  1.74k|  define_const(IPPROTO_RAW);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  228|  1.74k|#endif
  |  |  229|  1.74k|#if defined(IPPROTO_ROUTING) || defined(_WINSOCKAPI_)
  |  |  230|  1.74k|  define_const(IPPROTO_ROUTING);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  231|  1.74k|#endif
  |  |  232|  1.74k|#if defined(IPPROTO_TCP) || defined(_WINSOCKAPI_)
  |  |  233|  1.74k|  define_const(IPPROTO_TCP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  234|  1.74k|#endif
  |  |  235|  1.74k|#if defined(IPPROTO_UDP) || defined(_WINSOCKAPI_)
  |  |  236|  1.74k|  define_const(IPPROTO_UDP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  237|  1.74k|#endif
  |  |  238|  1.74k|#if defined(MCAST_BLOCK_SOURCE)
  |  |  239|  1.74k|  define_const(MCAST_BLOCK_SOURCE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|  1.74k|#endif
  |  |  241|  1.74k|#if defined(MCAST_JOIN_GROUP)
  |  |  242|  1.74k|  define_const(MCAST_JOIN_GROUP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  243|  1.74k|#endif
  |  |  244|  1.74k|#if defined(MCAST_JOIN_SOURCE_GROUP)
  |  |  245|  1.74k|  define_const(MCAST_JOIN_SOURCE_GROUP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  246|  1.74k|#endif
  |  |  247|  1.74k|#if defined(MCAST_LEAVE_GROUP)
  |  |  248|  1.74k|  define_const(MCAST_LEAVE_GROUP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|  1.74k|#endif
  |  |  250|  1.74k|#if defined(MCAST_LEAVE_SOURCE_GROUP)
  |  |  251|  1.74k|  define_const(MCAST_LEAVE_SOURCE_GROUP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  252|  1.74k|#endif
  |  |  253|  1.74k|#if defined(MCAST_MSFILTER)
  |  |  254|  1.74k|  define_const(MCAST_MSFILTER);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  255|  1.74k|#endif
  |  |  256|  1.74k|#if defined(MCAST_UNBLOCK_SOURCE)
  |  |  257|  1.74k|  define_const(MCAST_UNBLOCK_SOURCE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  258|  1.74k|#endif
  |  |  259|       |#if defined(MSG_BCAST)
  |  |  260|       |  define_const(MSG_BCAST);
  |  |  261|       |#endif
  |  |  262|  1.74k|#if defined(MSG_CTRUNC)
  |  |  263|  1.74k|  define_const(MSG_CTRUNC);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  264|  1.74k|#endif
  |  |  265|  1.74k|#if defined(MSG_DONTROUTE)
  |  |  266|  1.74k|  define_const(MSG_DONTROUTE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  267|  1.74k|#endif
  |  |  268|  1.74k|#if defined(MSG_DONTWAIT)
  |  |  269|  1.74k|  define_const(MSG_DONTWAIT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  270|  1.74k|#endif
  |  |  271|  1.74k|#if defined(MSG_EOR)
  |  |  272|  1.74k|  define_const(MSG_EOR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  273|  1.74k|#endif
  |  |  274|       |#if defined(MSG_MCAST)
  |  |  275|       |  define_const(MSG_MCAST);
  |  |  276|       |#endif
  |  |  277|  1.74k|#if defined(MSG_NOSIGNAL)
  |  |  278|  1.74k|  define_const(MSG_NOSIGNAL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  279|  1.74k|#endif
  |  |  280|  1.74k|#if defined(MSG_OOB)
  |  |  281|  1.74k|  define_const(MSG_OOB);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  282|  1.74k|#endif
  |  |  283|  1.74k|#if defined(MSG_PEEK)
  |  |  284|  1.74k|  define_const(MSG_PEEK);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  285|  1.74k|#endif
  |  |  286|  1.74k|#if defined(MSG_TRUNC)
  |  |  287|  1.74k|  define_const(MSG_TRUNC);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  288|  1.74k|#endif
  |  |  289|  1.74k|#if defined(MSG_WAITALL)
  |  |  290|  1.74k|  define_const(MSG_WAITALL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  291|  1.74k|#endif
  |  |  292|  1.74k|#if defined(NI_DGRAM)
  |  |  293|  1.74k|  define_const(NI_DGRAM);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  294|  1.74k|#endif
  |  |  295|  1.74k|#if defined(NI_MAXHOST)
  |  |  296|  1.74k|  define_const(NI_MAXHOST);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  297|  1.74k|#endif
  |  |  298|  1.74k|#if defined(NI_MAXSERV)
  |  |  299|  1.74k|  define_const(NI_MAXSERV);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  300|  1.74k|#endif
  |  |  301|  1.74k|#if defined(NI_NAMEREQD)
  |  |  302|  1.74k|  define_const(NI_NAMEREQD);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  303|  1.74k|#endif
  |  |  304|  1.74k|#if defined(NI_NOFQDN)
  |  |  305|  1.74k|  define_const(NI_NOFQDN);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  306|  1.74k|#endif
  |  |  307|  1.74k|#if defined(NI_NUMERICHOST)
  |  |  308|  1.74k|  define_const(NI_NUMERICHOST);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  309|  1.74k|#endif
  |  |  310|  1.74k|#if defined(NI_NUMERICSERV)
  |  |  311|  1.74k|  define_const(NI_NUMERICSERV);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  312|  1.74k|#endif
  |  |  313|  1.74k|#if defined(SHUT_RD)
  |  |  314|  1.74k|  define_const(SHUT_RD);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  315|  1.74k|#endif
  |  |  316|  1.74k|#if defined(SHUT_WR)
  |  |  317|  1.74k|  define_const(SHUT_WR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  318|  1.74k|#endif
  |  |  319|  1.74k|#if defined(SHUT_RDWR)
  |  |  320|  1.74k|  define_const(SHUT_RDWR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  321|  1.74k|#endif
  |  |  322|       |#if defined(SO_BINDANY)
  |  |  323|       |  define_const(SO_BINDANY);
  |  |  324|       |#endif
  |  |  325|  1.74k|#if defined(SO_BROADCAST)
  |  |  326|  1.74k|  define_const(SO_BROADCAST);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  327|  1.74k|#endif
  |  |  328|  1.74k|#if defined(SO_DEBUG)
  |  |  329|  1.74k|  define_const(SO_DEBUG);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  330|  1.74k|#endif
  |  |  331|  1.74k|#if defined(SO_DONTROUTE)
  |  |  332|  1.74k|  define_const(SO_DONTROUTE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  333|  1.74k|#endif
  |  |  334|  1.74k|#if defined(SO_ERROR)
  |  |  335|  1.74k|  define_const(SO_ERROR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  336|  1.74k|#endif
  |  |  337|  1.74k|#if defined(SO_KEEPALIVE)
  |  |  338|  1.74k|  define_const(SO_KEEPALIVE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  339|  1.74k|#endif
  |  |  340|  1.74k|#if defined(SO_LINGER)
  |  |  341|  1.74k|  define_const(SO_LINGER);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  342|  1.74k|#endif
  |  |  343|       |#if defined(SO_NOSIGPIPE)
  |  |  344|       |  define_const(SO_NOSIGPIPE);
  |  |  345|       |#endif
  |  |  346|  1.74k|#if defined(SO_OOBINLINE)
  |  |  347|  1.74k|  define_const(SO_OOBINLINE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  348|  1.74k|#endif
  |  |  349|  1.74k|#if defined(SO_PEERCRED)
  |  |  350|  1.74k|  define_const(SO_PEERCRED);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  351|  1.74k|#endif
  |  |  352|  1.74k|#if defined(SO_RCVBUF)
  |  |  353|  1.74k|  define_const(SO_RCVBUF);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  354|  1.74k|#endif
  |  |  355|  1.74k|#if defined(SO_RCVLOWAT)
  |  |  356|  1.74k|  define_const(SO_RCVLOWAT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  357|  1.74k|#endif
  |  |  358|  1.74k|#if defined(SO_RCVTIMEO)
  |  |  359|  1.74k|  define_const(SO_RCVTIMEO);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  360|  1.74k|#endif
  |  |  361|  1.74k|#if defined(SO_REUSEADDR)
  |  |  362|  1.74k|  define_const(SO_REUSEADDR);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  363|  1.74k|#endif
  |  |  364|  1.74k|#if defined(SO_REUSEPORT)
  |  |  365|  1.74k|  define_const(SO_REUSEPORT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  366|  1.74k|#endif
  |  |  367|       |#if defined(SO_RTABLE)
  |  |  368|       |  define_const(SO_RTABLE);
  |  |  369|       |#endif
  |  |  370|  1.74k|#if defined(SO_SNDBUF)
  |  |  371|  1.74k|  define_const(SO_SNDBUF);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  372|  1.74k|#endif
  |  |  373|  1.74k|#if defined(SO_SNDLOWAT)
  |  |  374|  1.74k|  define_const(SO_SNDLOWAT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  375|  1.74k|#endif
  |  |  376|  1.74k|#if defined(SO_SNDTIMEO)
  |  |  377|  1.74k|  define_const(SO_SNDTIMEO);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  378|  1.74k|#endif
  |  |  379|       |#if defined(SO_SPLICE)
  |  |  380|       |  define_const(SO_SPLICE);
  |  |  381|       |#endif
  |  |  382|  1.74k|#if defined(SO_TIMESTAMP)
  |  |  383|  1.74k|  define_const(SO_TIMESTAMP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  1.74k|#endif
  |  |  385|  1.74k|#if defined(SO_TYPE)
  |  |  386|  1.74k|  define_const(SO_TYPE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  387|  1.74k|#endif
  |  |  388|  1.74k|#if defined(SO_INCOMING_CPU)
  |  |  389|  1.74k|  define_const(SO_INCOMING_CPU);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  390|  1.74k|#endif
  |  |  391|  1.74k|#if defined(SO_INCOMING_NAPI_ID)
  |  |  392|  1.74k|  define_const(SO_INCOMING_NAPI_ID);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  393|  1.74k|#endif
  |  |  394|       |#if defined(SO_RTABLE)
  |  |  395|       |  define_const(SO_RTABLE);
  |  |  396|       |#endif
  |  |  397|       |#if defined(SO_SETFIB)
  |  |  398|       |  define_const(SO_SETFIB);
  |  |  399|       |#endif
  |  |  400|       |#if defined(SO_USER_COOKIE)
  |  |  401|       |  define_const(SO_USER_COOKIE);
  |  |  402|       |#endif
  |  |  403|  1.74k|#if defined(SOCK_DGRAM)
  |  |  404|  1.74k|  define_const(SOCK_DGRAM);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  405|  1.74k|#endif
  |  |  406|  1.74k|#if defined(SOCK_RAW)
  |  |  407|  1.74k|  define_const(SOCK_RAW);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  408|  1.74k|#endif
  |  |  409|  1.74k|#if defined(SOCK_SEQPACKET)
  |  |  410|  1.74k|  define_const(SOCK_SEQPACKET);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  411|  1.74k|#endif
  |  |  412|  1.74k|#if defined(SOCK_STREAM)
  |  |  413|  1.74k|  define_const(SOCK_STREAM);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  414|  1.74k|#endif
  |  |  415|  1.74k|#if defined(SOL_SOCKET)
  |  |  416|  1.74k|  define_const(SOL_SOCKET);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  417|  1.74k|#endif
  |  |  418|  1.74k|#if defined(SOL_IP)
  |  |  419|  1.74k|  define_const(SOL_IP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  420|  1.74k|#endif
  |  |  421|  1.74k|#if defined(SOL_TCP)
  |  |  422|  1.74k|  define_const(SOL_TCP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  423|  1.74k|#endif
  |  |  424|       |#if defined(TCP_CONGCTL)
  |  |  425|       |  define_const(TCP_CONGCTL);
  |  |  426|       |#endif
  |  |  427|  1.74k|#if defined(TCP_CONGESTION)
  |  |  428|  1.74k|  define_const(TCP_CONGESTION);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  429|  1.74k|#endif
  |  |  430|  1.74k|#if defined(TCP_CORK)
  |  |  431|  1.74k|  define_const(TCP_CORK);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  432|  1.74k|#endif
  |  |  433|  1.74k|#if defined(TCP_DEFER_ACCEPT)
  |  |  434|  1.74k|  define_const(TCP_DEFER_ACCEPT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  435|  1.74k|#endif
  |  |  436|  1.74k|#if defined(TCP_INFO)
  |  |  437|  1.74k|  define_const(TCP_INFO);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  438|  1.74k|#endif
  |  |  439|  1.74k|#if defined(TCP_KEEPCNT)
  |  |  440|  1.74k|  define_const(TCP_KEEPCNT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  441|  1.74k|#endif
  |  |  442|  1.74k|#if defined(TCP_KEEPIDLE)
  |  |  443|  1.74k|  define_const(TCP_KEEPIDLE);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  444|  1.74k|#endif
  |  |  445|       |#if defined(TCP_KEEPINIT)
  |  |  446|       |  define_const(TCP_KEEPINIT);
  |  |  447|       |#endif
  |  |  448|  1.74k|#if defined(TCP_KEEPINTVL)
  |  |  449|  1.74k|  define_const(TCP_KEEPINTVL);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  450|  1.74k|#endif
  |  |  451|  1.74k|#if defined(TCP_LINGER2)
  |  |  452|  1.74k|  define_const(TCP_LINGER2);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|  1.74k|#endif
  |  |  454|  1.74k|#if defined(TCP_MAXSEG)
  |  |  455|  1.74k|  define_const(TCP_MAXSEG);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|  1.74k|#endif
  |  |  457|  1.74k|#if defined(TCP_MD5SIG)
  |  |  458|  1.74k|  define_const(TCP_MD5SIG);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|  1.74k|#endif
  |  |  460|  1.74k|#if defined(TCP_NODELAY)
  |  |  461|  1.74k|  define_const(TCP_NODELAY);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  462|  1.74k|#endif
  |  |  463|  1.74k|#if defined(TCP_QUICKACK)
  |  |  464|  1.74k|  define_const(TCP_QUICKACK);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  465|  1.74k|#endif
  |  |  466|       |#if defined(TCP_SACK_ENABLE)
  |  |  467|       |  define_const(TCP_SACK_ENABLE);
  |  |  468|       |#endif
  |  |  469|  1.74k|#if defined(TCP_SYNCNT)
  |  |  470|  1.74k|  define_const(TCP_SYNCNT);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  471|  1.74k|#endif
  |  |  472|  1.74k|#if defined(TCP_WINDOW_CLAMP)
  |  |  473|  1.74k|  define_const(TCP_WINDOW_CLAMP);
  |  |  ------------------
  |  |  |  |  949|  1.74k|  do {                                                                \
  |  |  |  |  950|  1.74k|    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));  \
  |  |  |  |  951|  1.74k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (951:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  474|  1.74k|#endif
  |  |  475|       |#if defined(TCP_KEEPALIVE)
  |  |  476|       |  define_const(TCP_KEEPALIVE);
  |  |  477|       |#endif
  |  |  478|       |#if defined(TCP_CONNECTION_INFO)
  |  |  479|       |  define_const(TCP_CONNECTION_INFO);
  |  |  480|       |#endif
  ------------------
  954|  1.74k|}
mrb_mruby_socket_gem_final:
  958|  1.74k|{
  959|  1.74k|  mrb_value ai;
  960|  1.74k|  ai = mrb_mod_cv_get(mrb, mrb_class_get_id(mrb, MRB_SYM(Addrinfo)), MRB_SYM(_lastai));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
                ai = mrb_mod_cv_get(mrb, mrb_class_get_id(mrb, MRB_SYM(Addrinfo)), MRB_SYM(_lastai));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  961|  1.74k|  if (mrb_cptr_p(ai)) {
  ------------------
  |  |  189|  1.74k|#define mrb_cptr_p(o) WORDBOX_OBJ_TYPE_P(o, CPTR)
  |  |  ------------------
  |  |  |  |   78|  1.74k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.49k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.49k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 1.74k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 1.74k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  962|      0|    freeaddrinfo((struct addrinfo*)mrb_cptr(ai));
  ------------------
  |  |  151|      0|#define mrb_cptr(o)    mrb_val_union(o).vp->p
  ------------------
  963|      0|  }
  964|       |#ifdef _WIN32
  965|       |  WSACleanup();
  966|       |#endif
  967|  1.74k|}

mrb_mruby_sprintf_gem_init:
 1114|  1.74k|{
 1115|  1.74k|  struct RClass *krn = mrb->kernel_module;
 1116|  1.74k|  mrb_define_module_function(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1117|  1.74k|  mrb_define_module_function(mrb, krn, "format",  mrb_f_sprintf, MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1118|  1.74k|}
mrb_mruby_sprintf_gem_final:
 1122|  1.74k|{
 1123|  1.74k|}

mrb_mruby_string_ext_gem_init:
 1282|  1.74k|{
 1283|  1.74k|  struct RClass * s = mrb->string_class;
 1284|       |
 1285|  1.74k|  mrb_define_method(mrb, s, "dump",            mrb_str_dump,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1286|  1.74k|  mrb_define_method(mrb, s, "swapcase!",       str_swapcase_bang,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1287|  1.74k|  mrb_define_method(mrb, s, "swapcase",        str_swapcase,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1288|  1.74k|  mrb_define_method(mrb, s, "concat",          str_concat_m,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1289|  1.74k|  mrb_define_method(mrb, s, "<<",              str_concat_m,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1290|  1.74k|  mrb_define_method(mrb, s, "count",           str_count,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1291|  1.74k|  mrb_define_method(mrb, s, "tr",              str_tr_m,            MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1292|  1.74k|  mrb_define_method(mrb, s, "tr!",             str_tr_bang,         MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1293|  1.74k|  mrb_define_method(mrb, s, "tr_s",            str_tr_s,            MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1294|  1.74k|  mrb_define_method(mrb, s, "tr_s!",           str_tr_s_bang,       MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1295|  1.74k|  mrb_define_method(mrb, s, "squeeze",         str_squeeze_m,       MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1296|  1.74k|  mrb_define_method(mrb, s, "squeeze!",        str_squeeze_bang,    MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1297|  1.74k|  mrb_define_method(mrb, s, "delete",          str_delete_m,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1298|  1.74k|  mrb_define_method(mrb, s, "delete!",         str_delete_bang,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1299|  1.74k|  mrb_define_method(mrb, s, "start_with?",     str_start_with,      MRB_ARGS_REST());
  ------------------
  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  ------------------
 1300|  1.74k|  mrb_define_method(mrb, s, "end_with?",       str_end_with,        MRB_ARGS_REST());
  ------------------
  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  ------------------
 1301|  1.74k|  mrb_define_method(mrb, s, "hex",             str_hex,             MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1302|  1.74k|  mrb_define_method(mrb, s, "oct",             str_oct,             MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1303|  1.74k|  mrb_define_method(mrb, s, "chr",             str_chr,             MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1304|  1.74k|  mrb_define_method(mrb, s, "succ",            str_succ,            MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1305|  1.74k|  mrb_define_method(mrb, s, "succ!",           str_succ_bang,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1306|  1.74k|  mrb_define_method(mrb, s, "next",            str_succ,            MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1307|  1.74k|  mrb_define_method(mrb, s, "next!",           str_succ_bang,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1308|  1.74k|  mrb_define_method(mrb, s, "ord",             str_ord,             MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1309|  1.74k|  mrb_define_method(mrb, s, "delete_prefix!",  str_del_prefix_bang, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1310|  1.74k|  mrb_define_method(mrb, s, "delete_prefix",   str_del_prefix,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1311|  1.74k|  mrb_define_method(mrb, s, "delete_suffix!",  str_del_suffix_bang, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1312|  1.74k|  mrb_define_method(mrb, s, "delete_suffix",   str_del_suffix,      MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1313|  1.74k|  mrb_define_method(mrb, s, "casecmp",         str_casecmp,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1314|  1.74k|  mrb_define_method(mrb, s, "casecmp?",        str_casecmp_p,       MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1315|  1.74k|  mrb_define_method(mrb, s, "+@",              str_uplus,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1316|  1.74k|  mrb_define_method(mrb, s, "-@",              str_uminus,          MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1317|       |
 1318|  1.74k|  mrb_define_method(mrb, s, "__lines",         str_lines,           MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1319|       |
 1320|  1.74k|  mrb_define_method(mrb, mrb->integer_class, "chr", int_chr, MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1321|  1.74k|}
mrb_mruby_string_ext_gem_final:
 1325|  1.74k|{
 1326|  1.74k|}

mrb_mruby_struct_gem_init:
  654|  1.74k|{
  655|  1.74k|  struct RClass *st;
  656|  1.74k|  st = mrb_define_class(mrb, "Struct",  mrb->object_class);
  657|  1.74k|  MRB_SET_INSTANCE_TT(st, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  658|       |
  659|  1.74k|  mrb_define_class_method(mrb, st, "new",             mrb_struct_s_def,       MRB_ARGS_ANY());  /* 15.2.18.3.1  */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  660|       |
  661|  1.74k|  mrb_define_method(mrb, st,       "==",              mrb_struct_equal,       MRB_ARGS_REQ(1)); /* 15.2.18.4.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  662|  1.74k|  mrb_define_method(mrb, st,       "[]",              mrb_struct_aref,        MRB_ARGS_REQ(1)); /* 15.2.18.4.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  663|  1.74k|  mrb_define_method(mrb, st,       "[]=",             mrb_struct_aset,        MRB_ARGS_REQ(2)); /* 15.2.18.4.3  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  664|  1.74k|  mrb_define_method(mrb, st,       "members",         mrb_struct_members,     MRB_ARGS_NONE()); /* 15.2.18.4.6  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  665|  1.74k|  mrb_define_method(mrb, st,       "initialize",      mrb_struct_initialize,  MRB_ARGS_ANY());  /* 15.2.18.4.8  */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  666|  1.74k|  mrb_define_method(mrb, st,       "initialize_copy", mrb_struct_init_copy,   MRB_ARGS_REQ(1)); /* 15.2.18.4.9  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  667|  1.74k|  mrb_define_method(mrb, st,       "eql?",            mrb_struct_eql,         MRB_ARGS_REQ(1)); /* 15.2.18.4.12(x)  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  668|       |
  669|  1.74k|  mrb_define_method(mrb, st,       "size",            mrb_struct_len,         MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  670|  1.74k|  mrb_define_method(mrb, st,       "length",          mrb_struct_len,         MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  671|  1.74k|  mrb_define_method(mrb, st,       "to_a",            mrb_struct_to_a,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  672|  1.74k|  mrb_define_method(mrb, st,       "values",          mrb_struct_to_a,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  673|  1.74k|  mrb_define_method(mrb, st,       "to_h",            mrb_struct_to_h,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  674|  1.74k|  mrb_define_method(mrb, st,       "values_at",       mrb_struct_values_at,   MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  675|  1.74k|}
mrb_mruby_struct_gem_final:
  679|  1.74k|{
  680|  1.74k|}

mrb_mruby_symbol_ext_gem_init:
   64|  1.74k|{
   65|  1.74k|  struct RClass *s = mrb->symbol_class;
   66|       |#ifdef MRB_USE_ALL_SYMBOLS
   67|       |  mrb_define_class_method(mrb, s, "all_symbols", mrb_sym_all_symbols, MRB_ARGS_NONE());
   68|       |#endif
   69|  1.74k|  mrb_define_method(mrb, s, "length", mrb_sym_length, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
   70|  1.74k|  mrb_define_method(mrb, s, "size", mrb_sym_length, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
   71|  1.74k|}
mrb_mruby_symbol_ext_gem_final:
   75|  1.74k|{
   76|  1.74k|}

mrb_mruby_time_gem_init:
 1098|  1.74k|{
 1099|  1.74k|  struct RClass *tc;
 1100|       |  /* ISO 15.2.19.2 */
 1101|  1.74k|  tc = mrb_define_class(mrb, "Time", mrb->object_class);
 1102|  1.74k|  MRB_SET_INSTANCE_TT(tc, MRB_TT_CDATA);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 1103|  1.74k|  mrb_include_module(mrb, tc, mrb_module_get(mrb, "Comparable"));
 1104|  1.74k|  mrb_define_class_method(mrb, tc, "at", time_at_m, MRB_ARGS_ARG(1, 1));    /* 15.2.19.6.1 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1105|  1.74k|  mrb_define_class_method(mrb, tc, "gm", time_gm, MRB_ARGS_ARG(1,6));       /* 15.2.19.6.2 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1106|  1.74k|  mrb_define_class_method(mrb, tc, "local", time_local, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.3 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1107|  1.74k|  mrb_define_class_method(mrb, tc, "mktime", time_local, MRB_ARGS_ARG(1,6));/* 15.2.19.6.4 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1108|  1.74k|  mrb_define_class_method(mrb, tc, "now", time_now, MRB_ARGS_NONE());       /* 15.2.19.6.5 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1109|  1.74k|  mrb_define_class_method(mrb, tc, "utc", time_gm, MRB_ARGS_ARG(1,6));      /* 15.2.19.6.6 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1110|       |
 1111|  1.74k|  mrb_define_method(mrb, tc, "hash"   , time_hash   , MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1112|  1.74k|  mrb_define_method(mrb, tc, "eql?"   , time_eq     , MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1113|  1.74k|  mrb_define_method(mrb, tc, "=="     , time_eq     , MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1114|  1.74k|  mrb_define_method(mrb, tc, "<=>"    , time_cmp    , MRB_ARGS_REQ(1)); /* 15.2.19.7.1 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1115|  1.74k|  mrb_define_method(mrb, tc, "+"      , time_plus   , MRB_ARGS_REQ(1)); /* 15.2.19.7.2 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1116|  1.74k|  mrb_define_method(mrb, tc, "-"      , time_minus  , MRB_ARGS_REQ(1)); /* 15.2.19.7.3 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1117|  1.74k|  mrb_define_method(mrb, tc, "to_s"   , time_to_s   , MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1118|  1.74k|  mrb_define_method(mrb, tc, "inspect", time_to_s   , MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1119|  1.74k|  mrb_define_method(mrb, tc, "asctime", time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.4 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1120|  1.74k|  mrb_define_method(mrb, tc, "ctime"  , time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.5 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1121|  1.74k|  mrb_define_method(mrb, tc, "day"    , time_day    , MRB_ARGS_NONE()); /* 15.2.19.7.6 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1122|  1.74k|  mrb_define_method(mrb, tc, "dst?"   , time_dst_p  , MRB_ARGS_NONE()); /* 15.2.19.7.7 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1123|  1.74k|  mrb_define_method(mrb, tc, "getgm"  , time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.8 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1124|  1.74k|  mrb_define_method(mrb, tc, "getlocal",time_getlocal,MRB_ARGS_NONE()); /* 15.2.19.7.9 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1125|  1.74k|  mrb_define_method(mrb, tc, "getutc" , time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.10 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1126|  1.74k|  mrb_define_method(mrb, tc, "gmt?"   , time_utc_p  , MRB_ARGS_NONE()); /* 15.2.19.7.11 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1127|  1.74k|  mrb_define_method(mrb, tc, "gmtime" , time_utc    , MRB_ARGS_NONE()); /* 15.2.19.7.13 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1128|  1.74k|  mrb_define_method(mrb, tc, "hour"   , time_hour, MRB_ARGS_NONE());    /* 15.2.19.7.15 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1129|  1.74k|  mrb_define_method(mrb, tc, "localtime", time_localtime, MRB_ARGS_NONE()); /* 15.2.19.7.18 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1130|  1.74k|  mrb_define_method(mrb, tc, "mday"   , time_mday, MRB_ARGS_NONE());    /* 15.2.19.7.19 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1131|  1.74k|  mrb_define_method(mrb, tc, "min"    , time_min, MRB_ARGS_NONE());     /* 15.2.19.7.20 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1132|       |
 1133|  1.74k|  mrb_define_method(mrb, tc, "mon"  , time_mon, MRB_ARGS_NONE());       /* 15.2.19.7.21 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1134|  1.74k|  mrb_define_method(mrb, tc, "month", time_mon, MRB_ARGS_NONE());       /* 15.2.19.7.22 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1135|       |
 1136|  1.74k|  mrb_define_method(mrb, tc, "sec" , time_sec, MRB_ARGS_NONE());        /* 15.2.19.7.23 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1137|  1.74k|  mrb_define_method(mrb, tc, "to_i", time_to_i, MRB_ARGS_NONE());       /* 15.2.19.7.25 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1138|  1.74k|#ifndef MRB_NO_FLOAT
 1139|  1.74k|  mrb_define_method(mrb, tc, "to_f", time_to_f, MRB_ARGS_NONE());       /* 15.2.19.7.24 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1140|  1.74k|#endif
 1141|  1.74k|  mrb_define_method(mrb, tc, "usec", time_usec, MRB_ARGS_NONE());       /* 15.2.19.7.26 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1142|  1.74k|  mrb_define_method(mrb, tc, "utc" , time_utc, MRB_ARGS_NONE());        /* 15.2.19.7.27 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1143|  1.74k|  mrb_define_method(mrb, tc, "utc?", time_utc_p,MRB_ARGS_NONE());       /* 15.2.19.7.28 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1144|  1.74k|  mrb_define_method(mrb, tc, "wday", time_wday, MRB_ARGS_NONE());       /* 15.2.19.7.30 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1145|  1.74k|  mrb_define_method(mrb, tc, "yday", time_yday, MRB_ARGS_NONE());       /* 15.2.19.7.31 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1146|  1.74k|  mrb_define_method(mrb, tc, "year", time_year, MRB_ARGS_NONE());       /* 15.2.19.7.32 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1147|  1.74k|  mrb_define_method(mrb, tc, "zone", time_zone, MRB_ARGS_NONE());       /* 15.2.19.7.33 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1148|       |
 1149|  1.74k|  mrb_define_method(mrb, tc, "initialize", time_init, MRB_ARGS_REQ(1)); /* 15.2.19.7.16 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1150|  1.74k|  mrb_define_method(mrb, tc, "initialize_copy", time_init_copy, MRB_ARGS_REQ(1)); /* 15.2.19.7.17 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1151|       |
 1152|  1.74k|  mrb_define_method(mrb, tc, "sunday?", time_sunday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1153|  1.74k|  mrb_define_method(mrb, tc, "monday?", time_monday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1154|  1.74k|  mrb_define_method(mrb, tc, "tuesday?", time_tuesday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1155|  1.74k|  mrb_define_method(mrb, tc, "wednesday?", time_wednesday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1156|  1.74k|  mrb_define_method(mrb, tc, "thursday?", time_thursday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1157|  1.74k|  mrb_define_method(mrb, tc, "friday?", time_friday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1158|  1.74k|  mrb_define_method(mrb, tc, "saturday?", time_saturday, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1159|       |
 1160|       |  /*
 1161|       |    methods not available:
 1162|       |      gmt_offset(15.2.19.7.12)
 1163|       |      gmtoff(15.2.19.7.14)
 1164|       |      utc_offset(15.2.19.7.29)
 1165|       |  */
 1166|  1.74k|}
mrb_mruby_time_gem_final:
 1170|  1.74k|{
 1171|  1.74k|}
time.c:time_wrap:
  353|  7.54k|{
  354|  7.54k|  return mrb_obj_value(Data_Wrap_Struct(mrb, tc, &time_type, tm));
  ------------------
  |  |   40|  7.54k|  mrb_data_object_alloc(mrb,klass,ptr,type)
  ------------------
  355|  7.54k|}
time.c:time_alloc_time:
  360|  7.54k|{
  361|  7.54k|  struct mrb_time *tm;
  362|       |
  363|  7.54k|  tm = (struct mrb_time*)mrb_malloc(mrb, sizeof(struct mrb_time));
  364|  7.54k|  tm->sec  = sec;
  365|  7.54k|  tm->usec = usec;
  366|  7.54k|  if (MRB_TIME_T_UINT && tm->usec < 0) {
  ------------------
  |  |  202|  15.0k|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  ------------------
  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (366:26): [True: 0, False: 0]
  ------------------
  367|      0|    long sec2 = (long)NDIV(tm->usec,1000000); /* negative div */
  ------------------
  |  |   26|      0|#define NDIV(x,y) (-(-((x)+1)/(y))-1)
  ------------------
  368|      0|    tm->usec -= sec2 * 1000000;
  369|      0|    tm->sec += sec2;
  370|      0|  }
  371|  7.54k|  else if (tm->usec >= 1000000) {
  ------------------
  |  Branch (371:12): [True: 0, False: 7.54k]
  ------------------
  372|      0|    long sec2 = (long)(tm->usec / 1000000);
  373|      0|    tm->usec -= sec2 * 1000000;
  374|      0|    tm->sec += sec2;
  375|      0|  }
  376|  7.54k|  tm->timezone = timezone;
  377|  7.54k|  time_update_datetime(mrb, tm, TRUE);
  ------------------
  |  |   54|  7.54k|#  define TRUE 1
  ------------------
  378|       |
  379|  7.54k|  return tm;
  380|  7.54k|}
time.c:time_update_datetime:
  328|  7.54k|{
  329|  7.54k|  struct tm *aid;
  330|  7.54k|  time_t t = self->sec;
  331|       |
  332|  7.54k|  if (self->timezone == MRB_TIMEZONE_UTC) {
  ------------------
  |  Branch (332:7): [True: 3.77k, False: 3.76k]
  ------------------
  333|  3.77k|    aid = gmtime_r(&t, &self->datetime);
  334|  3.77k|  }
  335|  3.76k|  else {
  336|  3.76k|    aid = localtime_r(&t, &self->datetime);
  337|  3.76k|  }
  338|  7.54k|  if (!aid) {
  ------------------
  |  Branch (338:7): [True: 0, False: 7.54k]
  ------------------
  339|      0|    if (dealloc) mrb_free(mrb, self);
  ------------------
  |  Branch (339:9): [True: 0, False: 0]
  ------------------
  340|      0|    mrb_raisef(mrb, E_ARGUMENT_ERROR, "%v out of Time range", time_value_from_time_t(mrb, t));
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  341|       |    /* not reached */
  342|      0|    return NULL;
  343|      0|  }
  344|       |#ifdef NO_GMTIME_R
  345|       |  self->datetime = *aid; /* copy data */
  346|       |#endif
  347|       |
  348|  7.54k|  return self;
  349|  7.54k|}
time.c:time_at_m:
  476|  3.76k|{
  477|  3.76k|  mrb_value sec;
  478|  3.76k|  mrb_value usec = mrb_fixnum_value(0);
  479|       |
  480|  3.76k|  mrb_get_args(mrb, "o|o", &sec, &usec);
  481|       |
  482|  3.76k|  return time_make(mrb, mrb_class_ptr(self), sec, usec, MRB_TIMEZONE_LOCAL);
  ------------------
  |  |   24|  3.76k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  3.76k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  483|  3.76k|}
time.c:time_make:
  401|  3.76k|{
  402|  3.76k|  return time_wrap(mrb, c, time_alloc(mrb, sec, usec, timezone));
  403|  3.76k|}
time.c:time_alloc:
  384|  3.76k|{
  385|  3.76k|  time_t tsec, tusec;
  386|       |
  387|  3.76k|  tsec = mrb_to_time_t(mrb, sec, &tusec);
  388|  3.76k|  tusec += mrb_to_time_t(mrb, usec, NULL);
  389|       |
  390|  3.76k|  return time_alloc_time(mrb, tsec, tusec, timezone);
  391|  3.76k|}
time.c:mrb_to_time_t:
  225|  7.53k|{
  226|  7.53k|  time_t t;
  227|       |
  228|  7.53k|  switch (mrb_type(obj)) {
  229|      0|#ifndef MRB_NO_FLOAT
  230|      0|    case MRB_TT_FLOAT:
  ------------------
  |  Branch (230:5): [True: 0, False: 7.53k]
  ------------------
  231|      0|      {
  232|      0|        mrb_float f = mrb_float(obj);
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  233|       |
  234|      0|        mrb_check_num_exact(mrb, f);
  235|      0|        if (f >= ((mrb_float)MRB_TIME_MAX-1.0) || f < ((mrb_float)MRB_TIME_MIN+1.0)) {
  ------------------
  |  |  207|      0|#define MRB_TIME_MAX (time_t)(                                              \
  |  |  208|      0|  MRB_TIME_T_UINT ? (sizeof(time_t) <= 4 ? UINT32_MAX : UINT64_MAX) :       \
  |  |  ------------------
  |  |  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (208:22): [Folded - Ignored]
  |  |  ------------------
  |  |  209|      0|                    (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
  |  |  ------------------
  |  |  |  Branch (209:22): [Folded - Ignored]
  |  |  ------------------
  |  |  210|      0|)
  ------------------
                      if (f >= ((mrb_float)MRB_TIME_MAX-1.0) || f < ((mrb_float)MRB_TIME_MIN+1.0)) {
  ------------------
  |  |  203|      0|#define MRB_TIME_MIN (                                                      \
  |  |  204|      0|  MRB_TIME_T_UINT ? 0 :                                                     \
  |  |  ------------------
  |  |  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  205|      0|                    (sizeof(time_t) <= 4 ? INT32_MIN : INT64_MIN)           \
  |  |  ------------------
  |  |  |  Branch (205:22): [Folded - Ignored]
  |  |  ------------------
  |  |  206|      0|)
  ------------------
  |  Branch (235:13): [True: 0, False: 0]
  |  Branch (235:51): [True: 0, False: 0]
  ------------------
  236|      0|          goto out_of_range;
  237|      0|        }
  238|       |
  239|      0|        if (usec) {
  ------------------
  |  Branch (239:13): [True: 0, False: 0]
  ------------------
  240|      0|          double tt = floor(f);
  241|      0|          if (!isfinite(tt)) goto out_of_range;
  ------------------
  |  Branch (241:15): [True: 0, False: 0]
  ------------------
  242|      0|          t = (time_t)tt;
  243|      0|          *usec = (time_t)trunc((f - tt) * 1.0e+6);
  244|      0|        }
  245|      0|        else {
  246|      0|          double tt = round(f);
  247|      0|          if (!isfinite(tt)) goto out_of_range;
  ------------------
  |  Branch (247:15): [True: 0, False: 0]
  ------------------
  248|      0|          t = (time_t)tt;
  249|      0|        }
  250|      0|      }
  251|      0|      break;
  252|      0|#endif /* MRB_NO_FLOAT */
  253|       |
  254|      0|#ifdef MRB_USE_BIGINT
  255|      0|    case MRB_TT_BIGINT:
  ------------------
  |  Branch (255:5): [True: 0, False: 7.53k]
  ------------------
  256|      0|      {
  257|      0|        if (sizeof(time_t) > sizeof(mrb_int)) {
  ------------------
  |  Branch (257:13): [Folded - Ignored]
  ------------------
  258|      0|          if (MRB_TIME_T_UINT) {
  ------------------
  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  ------------------
  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  ------------------
  ------------------
  259|      0|            t = (time_t)mrb_bint_as_uint64(mrb, obj);
  260|      0|          }
  261|      0|          else {
  262|      0|            t = (time_t)mrb_bint_as_int64(mrb, obj);
  ------------------
  |  |  219|      0|#define mrb_bint_as_int64(mrb, x) mrb_bint_as_int((mrb), (x))
  ------------------
  263|      0|          }
  264|      0|          if (usec) { *usec = 0; }
  ------------------
  |  Branch (264:15): [True: 0, False: 0]
  ------------------
  265|      0|          break;
  266|      0|        }
  267|      0|        else {
  268|      0|          mrb_int i = mrb_bint_as_int(mrb, obj);
  269|      0|          obj = mrb_int_value(mrb, i);
  270|      0|        }
  271|      0|      }
  272|       |      /* fall through */
  273|      0|#endif  /* MRB_USE_BIGINT */
  274|       |
  275|  7.53k|    case MRB_TT_INTEGER:
  ------------------
  |  Branch (275:5): [True: 7.53k, False: 0]
  ------------------
  276|  7.53k|      {
  277|  7.53k|        mrb_int i = mrb_integer(obj);
  ------------------
  |  |  166|  7.53k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  278|       |
  279|  7.53k|        if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && (time_t)i > MRB_TIME_MAX) ||
  ------------------
  |  |   82|  7.53k|# define MRB_INT_MAX INT64_MAX
  ------------------
                      if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && (time_t)i > MRB_TIME_MAX) ||
  ------------------
  |  |  207|  15.0k|#define MRB_TIME_MAX (time_t)(                                              \
  |  |  208|  15.0k|  MRB_TIME_T_UINT ? (sizeof(time_t) <= 4 ? UINT32_MAX : UINT64_MAX) :       \
  |  |  ------------------
  |  |  |  |  202|  7.53k|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (208:22): [Folded - Ignored]
  |  |  ------------------
  |  |  209|  15.0k|                    (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
  |  |  ------------------
  |  |  |  Branch (209:22): [Folded - Ignored]
  |  |  ------------------
  |  |  210|  15.0k|)
  ------------------
                      if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && (time_t)i > MRB_TIME_MAX) ||
  ------------------
  |  |  207|      0|#define MRB_TIME_MAX (time_t)(                                              \
  |  |  208|      0|  MRB_TIME_T_UINT ? (sizeof(time_t) <= 4 ? UINT32_MAX : UINT64_MAX) :       \
  |  |  ------------------
  |  |  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (208:22): [Folded - Ignored]
  |  |  ------------------
  |  |  209|      0|                    (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
  |  |  ------------------
  |  |  |  Branch (209:22): [Folded - Ignored]
  |  |  ------------------
  |  |  210|      0|)
  ------------------
  |  Branch (279:14): [Folded - Ignored]
  |  Branch (279:44): [True: 0, False: 0]
  |  Branch (279:53): [True: 0, False: 0]
  ------------------
  280|  7.53k|            (0 > MRB_TIME_MIN && MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
  ------------------
  |  |  203|      0|#define MRB_TIME_MIN (                                                      \
  |  |  204|      0|  MRB_TIME_T_UINT ? 0 :                                                     \
  |  |  ------------------
  |  |  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  205|      0|                    (sizeof(time_t) <= 4 ? INT32_MIN : INT64_MIN)           \
  |  |  ------------------
  |  |  |  Branch (205:22): [Folded - Ignored]
  |  |  ------------------
  |  |  206|      0|)
  ------------------
                          (0 > MRB_TIME_MIN && MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
  ------------------
  |  |  203|      0|#define MRB_TIME_MIN (                                                      \
  |  |  204|      0|  MRB_TIME_T_UINT ? 0 :                                                     \
  |  |  ------------------
  |  |  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  205|      0|                    (sizeof(time_t) <= 4 ? INT32_MIN : INT64_MIN)           \
  |  |  ------------------
  |  |  |  Branch (205:22): [Folded - Ignored]
  |  |  ------------------
  |  |  206|      0|)
  ------------------
                          (0 > MRB_TIME_MIN && MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
  ------------------
  |  |   81|      0|# define MRB_INT_MIN INT64_MIN
  ------------------
                          (0 > MRB_TIME_MIN && MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
  ------------------
  |  |  203|      0|#define MRB_TIME_MIN (                                                      \
  |  |  204|      0|  MRB_TIME_T_UINT ? 0 :                                                     \
  |  |  ------------------
  |  |  |  |  202|      0|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  205|      0|                    (sizeof(time_t) <= 4 ? INT32_MIN : INT64_MIN)           \
  |  |  ------------------
  |  |  |  Branch (205:22): [Folded - Ignored]
  |  |  ------------------
  |  |  206|      0|)
  ------------------
  |  Branch (280:14): [Folded - Ignored]
  |  Branch (280:34): [Folded - Ignored]
  |  Branch (280:64): [True: 0, False: 0]
  ------------------
  281|      0|          goto out_of_range;
  282|      0|        }
  283|       |
  284|  7.53k|        t = (time_t)i;
  285|  7.53k|        if (usec) { *usec = 0; }
  ------------------
  |  Branch (285:13): [True: 3.76k, False: 3.76k]
  ------------------
  286|  7.53k|      }
  287|      0|      break;
  288|       |
  289|      0|    default:
  ------------------
  |  Branch (289:5): [True: 0, False: 7.53k]
  ------------------
  290|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "cannot convert %Y to time", obj);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  291|      0|      return 0;
  292|  7.53k|  }
  293|       |
  294|  7.53k|  return t;
  295|       |
  296|      0|out_of_range:
  297|      0|  mrb_raisef(mrb, E_ARGUMENT_ERROR, "%v out of Time range", obj);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  298|       |
  299|       |  /* not reached */
  300|      0|  return 0;
  301|  7.53k|}
time.c:time_gm:
  541|  3.77k|{
  542|  3.77k|  mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0, amin = 0, asec = 0, ausec = 0;
  543|       |
  544|  3.77k|  mrb_get_args(mrb, "i|iiiiii",
  545|  3.77k|                &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
  546|  3.77k|  return time_wrap(mrb, mrb_class_ptr(self),
  ------------------
  |  |   24|  3.77k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  3.77k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  547|  3.77k|          time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_UTC));
  548|  3.77k|}
time.c:time_mktime:
  489|  3.77k|{
  490|  3.77k|  time_t nowsecs;
  491|  3.77k|  struct tm nowtime = { 0 };
  492|       |
  493|  3.77k|#if MRB_INT_MAX > INT_MAX
  494|  3.77k|#define OUTINT(x) (((MRB_TIME_T_UINT ? 0 : INT_MIN) > (x)) || (x) > INT_MAX)
  495|       |#else
  496|       |#define OUTINT(x) 0
  497|       |#endif
  498|       |
  499|  3.77k|  ayear -= 1900;
  500|  3.77k|  if (OUTINT(ayear) ||
  ------------------
  |  |  494|  7.55k|#define OUTINT(x) (((MRB_TIME_T_UINT ? 0 : INT_MIN) > (x)) || (x) > INT_MAX)
  |  |  ------------------
  |  |  |  |  202|  3.77k|#define MRB_TIME_T_UINT (~(time_t)0 > 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (202:25): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 0, False: 3.77k]
  |  |  |  Branch (494:63): [True: 0, False: 3.77k]
  |  |  ------------------
  ------------------
  501|  3.77k|      amonth  < 1 || amonth  > 12 ||
  ------------------
  |  Branch (501:7): [True: 0, False: 3.77k]
  |  Branch (501:22): [True: 0, False: 3.77k]
  ------------------
  502|  3.77k|      aday    < 1 || aday    > 31 ||
  ------------------
  |  Branch (502:7): [True: 0, False: 3.77k]
  |  Branch (502:22): [True: 0, False: 3.77k]
  ------------------
  503|  3.77k|      ahour   < 0 || ahour   > 24 ||
  ------------------
  |  Branch (503:7): [True: 0, False: 3.77k]
  |  Branch (503:22): [True: 0, False: 3.77k]
  ------------------
  504|  3.77k|      (ahour == 24 && (amin > 0 || asec > 0)) ||
  ------------------
  |  Branch (504:8): [True: 0, False: 3.77k]
  |  Branch (504:24): [True: 0, False: 0]
  |  Branch (504:36): [True: 0, False: 0]
  ------------------
  505|  3.77k|      amin    < 0 || amin    > 59 ||
  ------------------
  |  Branch (505:7): [True: 0, False: 3.77k]
  |  Branch (505:22): [True: 0, False: 3.77k]
  ------------------
  506|  3.77k|      asec    < 0 || asec    > 60)
  ------------------
  |  Branch (506:7): [True: 0, False: 3.77k]
  |  Branch (506:22): [True: 0, False: 3.77k]
  ------------------
  507|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "argument out of range");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  508|       |
  509|  3.77k|  nowtime.tm_year  = (int)ayear;
  510|  3.77k|  nowtime.tm_mon   = (int)(amonth - 1);
  511|  3.77k|  nowtime.tm_mday  = (int)aday;
  512|  3.77k|  nowtime.tm_hour  = (int)ahour;
  513|  3.77k|  nowtime.tm_min   = (int)amin;
  514|  3.77k|  nowtime.tm_sec   = (int)asec;
  515|  3.77k|  nowtime.tm_isdst = -1;
  516|       |
  517|  3.77k|  time_t (*mk)(struct tm*);
  518|  3.77k|  if (timezone == MRB_TIMEZONE_UTC) {
  ------------------
  |  Branch (518:7): [True: 3.77k, False: 0]
  ------------------
  519|  3.77k|    mk = timegm;
  ------------------
  |  |  140|  3.77k|#define timegm my_timgm
  ------------------
  520|  3.77k|  }
  521|      0|  else {
  522|      0|    mk = mktime;
  523|      0|  }
  524|  3.77k|  nowsecs = (*mk)(&nowtime);
  525|  3.77k|  if (nowsecs == (time_t)-1) {
  ------------------
  |  Branch (525:7): [True: 0, False: 3.77k]
  ------------------
  526|      0|    nowtime.tm_sec += 1;        /* maybe Epoch-1 sec */
  527|      0|    nowsecs = (*mk)(&nowtime);
  528|      0|    if (nowsecs != 0) {         /* check if Epoch */
  ------------------
  |  Branch (528:9): [True: 0, False: 0]
  ------------------
  529|      0|      mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  530|      0|    }
  531|      0|    nowsecs = (time_t)-1;       /* valid Epoch-1 */
  532|      0|  }
  533|       |
  534|  3.77k|  return time_alloc_time(mrb, nowsecs, ausec, timezone);
  535|  3.77k|}
time.c:my_timgm:
  150|  3.77k|{
  151|  3.77k|  static const unsigned int ndays[2][12] = {
  152|  3.77k|    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
  153|  3.77k|    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
  154|  3.77k|  };
  155|  3.77k|  time_t r = 0;
  156|  3.77k|  int i;
  157|  3.77k|  unsigned int *nday = (unsigned int*) ndays[is_leapyear(tm->tm_year+1900)];
  158|       |
  159|  3.77k|  static const int epoch_year = 70;
  160|  3.77k|  if (tm->tm_year >= epoch_year) {
  ------------------
  |  Branch (160:7): [True: 0, False: 3.77k]
  ------------------
  161|      0|    for (i = epoch_year; i < tm->tm_year; ++i)
  ------------------
  |  Branch (161:26): [True: 0, False: 0]
  ------------------
  162|      0|      r += is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
  ------------------
  |  Branch (162:12): [True: 0, False: 0]
  ------------------
  163|      0|  }
  164|  3.77k|  else {
  165|  7.43M|    for (i = tm->tm_year; i < epoch_year; ++i)
  ------------------
  |  Branch (165:27): [True: 7.43M, False: 3.77k]
  ------------------
  166|  7.43M|      r -= is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
  ------------------
  |  Branch (166:12): [True: 1.80M, False: 5.63M]
  ------------------
  167|  3.77k|  }
  168|  3.77k|  for (i = 0; i < tm->tm_mon; ++i)
  ------------------
  |  Branch (168:15): [True: 0, False: 3.77k]
  ------------------
  169|      0|    r += nday[i] * 24 * 60 * 60;
  170|  3.77k|  r += (tm->tm_mday - 1) * 24 * 60 * 60;
  171|  3.77k|  r += tm->tm_hour * 60 * 60;
  172|  3.77k|  r += tm->tm_min * 60;
  173|  3.77k|  r += tm->tm_sec;
  174|  3.77k|  return r;
  175|  3.77k|}
time.c:is_leapyear:
  144|  7.43M|{
  145|  7.43M|  return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
  ------------------
  |  Branch (145:10): [True: 1.86M, False: 5.57M]
  |  Branch (145:27): [True: 1.78M, False: 77.3k]
  |  Branch (145:45): [True: 20.7k, False: 56.6k]
  ------------------
  146|  7.43M|}

_Z6FuzzRBPKhm:
   15|  1.74k|int FuzzRB(const uint8_t *Data, size_t size) {
   16|  1.74k|  mrb_value v;
   17|  1.74k|  mrb_state *mrb = mrb_open();
   18|  1.74k|  if (!mrb)
  ------------------
  |  Branch (18:7): [True: 0, False: 1.74k]
  ------------------
   19|      0|    return 0;
   20|       |
   21|  1.74k|  char *code = (char*)malloc(size+1);
   22|  1.74k|  if (!code)
  ------------------
  |  Branch (22:7): [True: 0, False: 1.74k]
  ------------------
   23|      0|    return 0;
   24|  1.74k|  memcpy(code, Data, size);
   25|  1.74k|  code[size] = '\0';
   26|       |
   27|  1.74k|  if (const char *dump_path = getenv("PROTO_FUZZER_DUMP_PATH")) {
  ------------------
  |  Branch (27:19): [True: 0, False: 1.74k]
  ------------------
   28|       |    // With libFuzzer binary run this to generate an RB file x.rb:
   29|       |    // PROTO_FUZZER_DUMP_PATH=x.rb ./a.out proto-input
   30|      0|    std::ofstream of(dump_path);
   31|      0|    of.write(code, size);
   32|      0|  }
   33|  1.74k|  std::cout << "\n\n############\n" << code << "\n############\n\n";
   34|  1.74k|  v = mrb_load_string(mrb, code);
   35|  1.74k|  mrb_close(mrb);
   36|       |
   37|  1.74k|  free(code);
   38|  1.74k|  return 0;
   39|  1.74k|}
mruby_proto_fuzzer.cpp:_ZL17TestOneProtoInputRKN11ruby_fuzzer8FunctionE:
   41|  1.74k|DEFINE_PROTO_FUZZER(const Function &function) {
   42|  1.74k|  protoConverter converter;
   43|  1.74k|  auto s = converter.FunctionToString(function);
   44|  1.74k|  (void)FuzzRB((const uint8_t*)s.data(), s.size());
   45|  1.74k|}

_ZN11ruby_fuzzer14protoConverter13removeSpecialERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
    6|   258k|{
    7|   258k|  std::string tmp(x);
    8|   258k|  if (!tmp.empty())
  ------------------
  |  Branch (8:7): [True: 43.0k, False: 215k]
  ------------------
    9|  43.0k|    tmp.erase(std::remove_if(tmp.begin(), tmp.end(),
   10|  43.0k|                             [](char c) { return !(std::isalpha(c) || std::isdigit(c)); } ), tmp.end());
   11|   258k|  return tmp;
   12|   258k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_7ArrTypeE:
   15|  55.7k|{
   16|  55.7k|  if (x.elements_size() > 0) {
  ------------------
  |  Branch (16:7): [True: 7.26k, False: 48.4k]
  ------------------
   17|  7.26k|    int i = x.elements_size();
   18|  7.26k|    m_output << "[";
   19|   246k|    for (auto &e : x.elements()) {
  ------------------
  |  Branch (19:18): [True: 246k, False: 7.26k]
  ------------------
   20|   246k|      i--;
   21|   246k|      if (i == 0) {
  ------------------
  |  Branch (21:11): [True: 7.26k, False: 238k]
  ------------------
   22|  7.26k|        visit(e);
   23|   238k|      } else {
   24|   238k|        visit(e);
   25|   238k|        m_output << ", ";
   26|   238k|      }
   27|   246k|    }
   28|  7.26k|    m_output << "]";
   29|  48.4k|  } else {
   30|  48.4k|    m_output << "[1]";
   31|  48.4k|  }
   32|  55.7k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_5ArrayE:
   35|  55.7k|{
   36|  55.7k|  switch (x.arr_func()) {
  ------------------
  |  Branch (36:11): [True: 0, False: 55.7k]
  ------------------
   37|  12.8k|    case Array::FLATTEN:
  ------------------
  |  Branch (37:5): [True: 12.8k, False: 42.8k]
  ------------------
   38|  12.8k|      visit(x.arr_arg());
   39|  12.8k|      m_output << ".flatten";
   40|  12.8k|      break;
   41|     24|    case Array::COMPACT:
  ------------------
  |  Branch (41:5): [True: 24, False: 55.7k]
  ------------------
   42|     24|      visit(x.arr_arg());
   43|     24|      m_output << ".compact";
   44|     24|      break;
   45|  1.53k|    case Array::FETCH:
  ------------------
  |  Branch (45:5): [True: 1.53k, False: 54.2k]
  ------------------
   46|  1.53k|      visit(x.arr_arg());
   47|  1.53k|      m_output << ".fetch";
   48|  1.53k|      break;
   49|    949|    case Array::FILL:
  ------------------
  |  Branch (49:5): [True: 949, False: 54.8k]
  ------------------
   50|    949|      visit(x.arr_arg());
   51|    949|      m_output << ".fill";
   52|    949|      break;
   53|    663|    case Array::ROTATE:
  ------------------
  |  Branch (53:5): [True: 663, False: 55.0k]
  ------------------
   54|    663|      visit(x.arr_arg());
   55|    663|      m_output << ".rotate";
   56|    663|      break;
   57|  1.05k|    case Array::ROTATE_E:
  ------------------
  |  Branch (57:5): [True: 1.05k, False: 54.7k]
  ------------------
   58|  1.05k|      visit(x.arr_arg());
   59|  1.05k|      m_output << ".rotate!";
   60|  1.05k|      break;
   61|    283|    case Array::DELETEIF:
  ------------------
  |  Branch (61:5): [True: 283, False: 55.4k]
  ------------------
   62|    283|      visit(x.arr_arg());
   63|    283|      m_output << ".delete_if";
   64|    283|      break;
   65|  3.19k|    case Array::INSERT:
  ------------------
  |  Branch (65:5): [True: 3.19k, False: 52.5k]
  ------------------
   66|  3.19k|      visit(x.arr_arg());
   67|  3.19k|      m_output << ".insert";
   68|  3.19k|      break;
   69|    149|    case Array::BSEARCH:
  ------------------
  |  Branch (69:5): [True: 149, False: 55.6k]
  ------------------
   70|    149|      visit(x.arr_arg());
   71|    149|      m_output << ".bsearch";
   72|    149|      break;
   73|     24|    case Array::KEEPIF:
  ------------------
  |  Branch (73:5): [True: 24, False: 55.7k]
  ------------------
   74|     24|      visit(x.arr_arg());
   75|     24|      m_output << ".keep_if";
   76|     24|      break;
   77|    170|    case Array::SELECT:
  ------------------
  |  Branch (77:5): [True: 170, False: 55.5k]
  ------------------
   78|    170|      visit(x.arr_arg());
   79|    170|      m_output << ".select";
   80|    170|      break;
   81|    455|    case Array::VALUES_AT:
  ------------------
  |  Branch (81:5): [True: 455, False: 55.3k]
  ------------------
   82|    455|      visit(x.arr_arg());
   83|    455|      m_output << ".values_at";
   84|    455|      break;
   85|  2.44k|    case Array::BLOCK:
  ------------------
  |  Branch (85:5): [True: 2.44k, False: 53.3k]
  ------------------
   86|  2.44k|      visit(x.arr_arg());
   87|  2.44k|      m_output << ".index";
   88|  2.44k|      break;
   89|  3.48k|    case Array::DIG:
  ------------------
  |  Branch (89:5): [True: 3.48k, False: 52.2k]
  ------------------
   90|  3.48k|      visit(x.arr_arg());
   91|  3.48k|      m_output << ".dig";
   92|  3.48k|      break;
   93|  1.57k|    case Array::SLICE:
  ------------------
  |  Branch (93:5): [True: 1.57k, False: 54.1k]
  ------------------
   94|  1.57k|      visit(x.arr_arg());
   95|  1.57k|      m_output << ".slice";
   96|  1.57k|      break;
   97|  2.57k|    case Array::PERM:
  ------------------
  |  Branch (97:5): [True: 2.57k, False: 53.1k]
  ------------------
   98|  2.57k|      visit(x.arr_arg());
   99|  2.57k|      m_output << ".permutation";
  100|  2.57k|      break;
  101|  23.6k|    case Array::COMB:
  ------------------
  |  Branch (101:5): [True: 23.6k, False: 32.1k]
  ------------------
  102|  23.6k|      visit(x.arr_arg());
  103|  23.6k|      m_output << ".combination";
  104|  23.6k|      break;
  105|    416|    case Array::ASSOC:
  ------------------
  |  Branch (105:5): [True: 416, False: 55.3k]
  ------------------
  106|    416|      visit(x.arr_arg());
  107|    416|      m_output << ".assoc";
  108|    416|      break;
  109|    285|    case Array::RASSOC:
  ------------------
  |  Branch (109:5): [True: 285, False: 55.4k]
  ------------------
  110|    285|      visit(x.arr_arg());
  111|    285|      m_output << ".rassoc";
  112|    285|      break;
  113|  55.7k|  }
  114|  55.7k|  m_output << "(";
  115|  55.7k|  visit(x.val_arg());
  116|  55.7k|  m_output << ")";
  117|  55.7k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_19AssignmentStatementE:
  120|   212k|{
  121|   212k|  m_output << "var_" << m_numLiveVars << " = ";
  122|   212k|  visit(x.rvalue());
  123|   212k|  m_numVarsPerScope.top()++;
  124|   212k|  m_numLiveVars++;
  125|   212k|  m_output << "\n";
  126|   212k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_8BinaryOpE:
  129|   130k|{
  130|   130k|  m_output << "(";
  131|   130k|  visit(x.left());
  132|   130k|  switch (x.op()) {
  ------------------
  |  Branch (132:11): [True: 0, False: 130k]
  ------------------
  133|  19.7k|    case BinaryOp::ADD: m_output << " + "; break;
  ------------------
  |  Branch (133:5): [True: 19.7k, False: 110k]
  ------------------
  134|  21.9k|    case BinaryOp::SUB: m_output << " - "; break;
  ------------------
  |  Branch (134:5): [True: 21.9k, False: 108k]
  ------------------
  135|  18.2k|    case BinaryOp::MUL: m_output << " * "; break;
  ------------------
  |  Branch (135:5): [True: 18.2k, False: 112k]
  ------------------
  136|  12.8k|    case BinaryOp::DIV: m_output << " / "; break;
  ------------------
  |  Branch (136:5): [True: 12.8k, False: 117k]
  ------------------
  137|  9.50k|    case BinaryOp::MOD: m_output << " % "; break;
  ------------------
  |  Branch (137:5): [True: 9.50k, False: 120k]
  ------------------
  138|  9.95k|    case BinaryOp::XOR: m_output << " ^ "; break;
  ------------------
  |  Branch (138:5): [True: 9.95k, False: 120k]
  ------------------
  139|  4.11k|    case BinaryOp::AND: m_output << " and "; break;
  ------------------
  |  Branch (139:5): [True: 4.11k, False: 126k]
  ------------------
  140|  2.09k|    case BinaryOp::OR: m_output << " or "; break;
  ------------------
  |  Branch (140:5): [True: 2.09k, False: 128k]
  ------------------
  141|  2.45k|    case BinaryOp::EQ: m_output << " == "; break;
  ------------------
  |  Branch (141:5): [True: 2.45k, False: 127k]
  ------------------
  142|  6.40k|    case BinaryOp::NE: m_output << " != "; break;
  ------------------
  |  Branch (142:5): [True: 6.40k, False: 123k]
  ------------------
  143|  4.13k|    case BinaryOp::LE: m_output << " <= "; break;
  ------------------
  |  Branch (143:5): [True: 4.13k, False: 126k]
  ------------------
  144|  1.92k|    case BinaryOp::GE: m_output << " >= "; break;
  ------------------
  |  Branch (144:5): [True: 1.92k, False: 128k]
  ------------------
  145|  1.41k|    case BinaryOp::LT: m_output << " < "; break;
  ------------------
  |  Branch (145:5): [True: 1.41k, False: 128k]
  ------------------
  146|  1.51k|    case BinaryOp::GT: m_output << " > "; break;
  ------------------
  |  Branch (146:5): [True: 1.51k, False: 128k]
  ------------------
  147|  14.0k|    case BinaryOp::RS: m_output << " >> "; break;
  ------------------
  |  Branch (147:5): [True: 14.0k, False: 116k]
  ------------------
  148|   130k|  }
  149|   130k|  visit(x.right());
  150|   130k|  m_output << ")";
  151|   130k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_12BuiltinFuncsE:
  154|   118k|{
  155|   118k|  switch (x.bifunc_oneof_case()) {
  ------------------
  |  Branch (155:11): [True: 0, False: 118k]
  ------------------
  156|  20.6k|    case BuiltinFuncs::kOs:
  ------------------
  |  Branch (156:5): [True: 20.6k, False: 98.2k]
  ------------------
  157|  20.6k|      visit(x.os());
  158|  20.6k|      break;
  159|  10.2k|    case BuiltinFuncs::kTime:
  ------------------
  |  Branch (159:5): [True: 10.2k, False: 108k]
  ------------------
  160|  10.2k|      visit(x.time());
  161|  10.2k|      break;
  162|  55.7k|    case BuiltinFuncs::kArr:
  ------------------
  |  Branch (162:5): [True: 55.7k, False: 63.1k]
  ------------------
  163|  55.7k|      visit(x.arr());
  164|  55.7k|      break;
  165|  9.19k|    case BuiltinFuncs::kMops:
  ------------------
  |  Branch (165:5): [True: 9.19k, False: 109k]
  ------------------
  166|  9.19k|      visit(x.mops());
  167|  9.19k|      break;
  168|  23.0k|    case BuiltinFuncs::BIFUNC_ONEOF_NOT_SET:
  ------------------
  |  Branch (168:5): [True: 23.0k, False: 95.8k]
  ------------------
  169|  23.0k|      m_output << "1";
  170|  23.0k|      break;
  171|   118k|  }
  172|   118k|  m_output << "\n";
  173|   118k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_5ConstE:
  176|   284k|{
  177|   284k|  switch (x.const_oneof_case()) {
  ------------------
  |  Branch (177:11): [True: 0, False: 284k]
  ------------------
  178|  32.2k|    case Const::kIntLit:
  ------------------
  |  Branch (178:5): [True: 32.2k, False: 252k]
  ------------------
  179|  32.2k|      m_output << "(" << (x.int_lit() % 13) << ")";
  180|  32.2k|      break;
  181|  12.1k|    case Const::kBoolVal:
  ------------------
  |  Branch (181:5): [True: 12.1k, False: 272k]
  ------------------
  182|  12.1k|      m_output << "(" << x.bool_val() << ")";
  183|  12.1k|      break;
  184|   240k|    case Const::CONST_ONEOF_NOT_SET:
  ------------------
  |  Branch (184:5): [True: 240k, False: 44.3k]
  ------------------
  185|   240k|      m_output << "1";
  186|   240k|      break;
  187|   284k|  }
  188|   284k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_8FunctionE:
  191|  1.74k|{
  192|  1.74k|  m_output << "def foo()\nvar_0 = 1\n";
  193|  1.74k|  visit(x.statements());
  194|  1.74k|  m_output << "end\n";
  195|  1.74k|  m_output << "foo\n";
  196|  1.74k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_8HashTypeE:
  199|  20.6k|{
  200|  20.6k|  if (x.keyval_size() > 0) {
  ------------------
  |  Branch (200:7): [True: 3.61k, False: 17.0k]
  ------------------
  201|  3.61k|    int i = x.keyval_size();
  202|  3.61k|    m_output << "{";
  203|   129k|    for (auto &e : x.keyval()) {
  ------------------
  |  Branch (203:18): [True: 129k, False: 3.61k]
  ------------------
  204|   129k|      i--;
  205|   129k|      if (i == 0) {
  ------------------
  |  Branch (205:11): [True: 3.61k, False: 125k]
  ------------------
  206|  3.61k|        visit(e);
  207|  3.61k|      }
  208|   125k|      else {
  209|   125k|        visit(e);
  210|   125k|        m_output << ", ";
  211|   125k|      }
  212|   129k|    }
  213|  3.61k|    m_output << "}";
  214|  3.61k|  }
  215|  20.6k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_6IfElseE:
  218|  17.5k|{
  219|  17.5k|  m_output << "if ";
  220|  17.5k|  visit(x.cond());
  221|  17.5k|  m_output << "\n";
  222|  17.5k|  visit(x.if_body());
  223|  17.5k|  m_output << "\nelse\n";
  224|  17.5k|  visit(x.else_body());
  225|  17.5k|  m_output << "\nend\n";
  226|  17.5k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_6KVPairE:
  229|   129k|{
  230|   129k|  m_output << "\"" << removeSpecial(x.key()) << "\"";
  231|   129k|  m_output << " => ";
  232|   129k|  m_output << "\"" << removeSpecial(x.val()) << "\"";
  233|   129k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_9MathConstE:
  236|  3.08k|{
  237|  3.08k|  switch (x.math_const()) {
  ------------------
  |  Branch (237:11): [True: 0, False: 3.08k]
  ------------------
  238|    290|    case MathConst::PI:
  ------------------
  |  Branch (238:5): [True: 290, False: 2.79k]
  ------------------
  239|    290|      m_output << "Math::PI";
  240|    290|      break;
  241|  2.79k|    case MathConst::E:
  ------------------
  |  Branch (241:5): [True: 2.79k, False: 290]
  ------------------
  242|  2.79k|      m_output << "Math::E";
  243|  2.79k|      break;
  244|  3.08k|  }
  245|  3.08k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_7MathOpsE:
  248|  9.19k|{
  249|  9.19k|  switch (x.math_op()) {
  ------------------
  |  Branch (249:11): [True: 0, False: 9.19k]
  ------------------
  250|  2.45k|    case MathOps::CBRT:
  ------------------
  |  Branch (250:5): [True: 2.45k, False: 6.73k]
  ------------------
  251|  2.45k|      m_output << "Math.cbrt(";
  252|  2.45k|      visit(x.math_arg());
  253|  2.45k|      m_output << ")";
  254|  2.45k|      break;
  255|    581|    case MathOps::COS:
  ------------------
  |  Branch (255:5): [True: 581, False: 8.61k]
  ------------------
  256|    581|      m_output << "Math.cos(";
  257|    581|      visit(x.math_arg());
  258|    581|      m_output << ")";
  259|    581|      break;
  260|    938|    case MathOps::ERF:
  ------------------
  |  Branch (260:5): [True: 938, False: 8.25k]
  ------------------
  261|    938|      m_output << "Math.erf(";
  262|    938|      visit(x.math_arg());
  263|    938|      m_output << ")";
  264|    938|      break;
  265|    530|    case MathOps::ERFC:
  ------------------
  |  Branch (265:5): [True: 530, False: 8.66k]
  ------------------
  266|    530|      m_output << "Math.erfc(";
  267|    530|      visit(x.math_arg());
  268|    530|      m_output << ")";
  269|    530|      break;
  270|  1.80k|    case MathOps::LOG:
  ------------------
  |  Branch (270:5): [True: 1.80k, False: 7.39k]
  ------------------
  271|  1.80k|      m_output << "Math.log(";
  272|  1.80k|      visit(x.math_arg());
  273|  1.80k|      m_output << ")";
  274|  1.80k|      break;
  275|    331|    case MathOps::LOG10:
  ------------------
  |  Branch (275:5): [True: 331, False: 8.86k]
  ------------------
  276|    331|      m_output << "Math.log10(";
  277|    331|      visit(x.math_arg());
  278|    331|      m_output << ")";
  279|    331|      break;
  280|    427|    case MathOps::LOG2:
  ------------------
  |  Branch (280:5): [True: 427, False: 8.76k]
  ------------------
  281|    427|      m_output << "Math.log2(";
  282|    427|      visit(x.math_arg());
  283|    427|      m_output << ")";
  284|    427|      break;
  285|  1.03k|    case MathOps::SIN:
  ------------------
  |  Branch (285:5): [True: 1.03k, False: 8.15k]
  ------------------
  286|  1.03k|      m_output << "Math.sin(";
  287|  1.03k|      visit(x.math_arg());
  288|  1.03k|      m_output << ")";
  289|  1.03k|      break;
  290|    266|    case MathOps::SQRT:
  ------------------
  |  Branch (290:5): [True: 266, False: 8.92k]
  ------------------
  291|    266|      m_output << "Math.sqrt(";
  292|    266|      visit(x.math_arg());
  293|    266|      m_output << ")";
  294|    266|      break;
  295|    824|    case MathOps::TAN:
  ------------------
  |  Branch (295:5): [True: 824, False: 8.37k]
  ------------------
  296|    824|      m_output << "Math.tan(";
  297|    824|      visit(x.math_arg());
  298|    824|      m_output << ")";
  299|    824|      break;
  300|  9.19k|  }
  301|  9.19k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_8MathTypeE:
  304|  9.19k|{
  305|  9.19k|  switch (x.math_arg_oneof_case()) {
  ------------------
  |  Branch (305:11): [True: 0, False: 9.19k]
  ------------------
  306|  1.32k|    case MathType::kMathRval:
  ------------------
  |  Branch (306:5): [True: 1.32k, False: 7.86k]
  ------------------
  307|  1.32k|      visit(x.math_rval());
  308|  1.32k|      break;
  309|  3.08k|    case MathType::kMathConst:
  ------------------
  |  Branch (309:5): [True: 3.08k, False: 6.11k]
  ------------------
  310|  3.08k|      visit(x.math_const());
  311|  3.08k|      break;
  312|  4.78k|    case MathType::MATH_ARG_ONEOF_NOT_SET:
  ------------------
  |  Branch (312:5): [True: 4.78k, False: 4.41k]
  ------------------
  313|  4.78k|      m_output << "1";
  314|  4.78k|      break;
  315|  9.19k|  }
  316|  9.19k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_11ObjectSpaceE:
  319|  20.6k|{
  320|  20.6k|  switch (x.os_func()) {
  ------------------
  |  Branch (320:11): [True: 0, False: 20.6k]
  ------------------
  321|  20.6k|    case ObjectSpace::COUNT:
  ------------------
  |  Branch (321:5): [True: 20.6k, False: 0]
  ------------------
  322|  20.6k|      m_output << "ObjectSpace.count_objects";
  323|  20.6k|      break;
  324|  20.6k|  }
  325|  20.6k|  m_output << "(";
  326|  20.6k|  visit(x.os_arg());
  327|  20.6k|  m_output << ")" << "\n";
  328|  20.6k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_6RvalueE:
  331|   573k|{
  332|   573k|  switch (x.rvalue_oneof_case()) {
  ------------------
  |  Branch (332:11): [True: 0, False: 573k]
  ------------------
  333|  72.8k|    case Rvalue::kVarref:
  ------------------
  |  Branch (333:5): [True: 72.8k, False: 501k]
  ------------------
  334|  72.8k|      visit(x.varref());
  335|  72.8k|      break;
  336|  38.2k|    case Rvalue::kCons:
  ------------------
  |  Branch (336:5): [True: 38.2k, False: 535k]
  ------------------
  337|  38.2k|      visit(x.cons());
  338|  38.2k|      break;
  339|   130k|    case Rvalue::kBinop:
  ------------------
  |  Branch (339:5): [True: 130k, False: 443k]
  ------------------
  340|   130k|      visit(x.binop());
  341|   130k|      break;
  342|   332k|    case Rvalue::RVALUE_ONEOF_NOT_SET:
  ------------------
  |  Branch (342:5): [True: 332k, False: 241k]
  ------------------
  343|   332k|      m_output << "1";
  344|   332k|      break;
  345|   573k|  }
  346|   573k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_9StatementE:
  349|   549k|{
  350|   549k|  switch (x.stmt_oneof_case()) {
  ------------------
  |  Branch (350:11): [True: 0, False: 549k]
  ------------------
  351|   212k|    case Statement::kAssignment:
  ------------------
  |  Branch (351:5): [True: 212k, False: 337k]
  ------------------
  352|   212k|      visit(x.assignment());
  353|   212k|      break;
  354|  17.5k|    case Statement::kIfelse:
  ------------------
  |  Branch (354:5): [True: 17.5k, False: 532k]
  ------------------
  355|  17.5k|      visit(x.ifelse());
  356|  17.5k|      break;
  357|  8.56k|    case Statement::kTernaryStmt:
  ------------------
  |  Branch (357:5): [True: 8.56k, False: 541k]
  ------------------
  358|  8.56k|      visit(x.ternary_stmt());
  359|  8.56k|      break;
  360|   118k|    case Statement::kBuiltins:
  ------------------
  |  Branch (360:5): [True: 118k, False: 431k]
  ------------------
  361|   118k|      visit(x.builtins());
  362|   118k|      break;
  363|  33.0k|    case Statement::kBlockstmt:
  ------------------
  |  Branch (363:5): [True: 33.0k, False: 516k]
  ------------------
  364|  33.0k|      visit(x.blockstmt());
  365|  33.0k|      break;
  366|   159k|    case Statement::STMT_ONEOF_NOT_SET:
  ------------------
  |  Branch (366:5): [True: 159k, False: 390k]
  ------------------
  367|   159k|      break;
  368|   549k|  }
  369|   549k|  m_output << "\n";
  370|   549k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_12StatementSeqE:
  373|  69.8k|{
  374|  69.8k|  if (x.statements_size() > 0) {
  ------------------
  |  Branch (374:7): [True: 31.8k, False: 38.0k]
  ------------------
  375|  31.8k|    m_numVarsPerScope.push(0);
  376|  31.8k|    m_output << "@scope ||= begin\n";
  377|  31.8k|    for (auto &st : x.statements())
  ------------------
  |  Branch (377:19): [True: 549k, False: 31.8k]
  ------------------
  378|   549k|      visit(st);
  379|  31.8k|    m_output << "end\n";
  380|  31.8k|    m_numLiveVars -= m_numVarsPerScope.top();
  381|  31.8k|    m_numVarsPerScope.pop();
  382|  31.8k|  }
  383|  69.8k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_7TernaryE:
  423|  8.56k|{
  424|  8.56k|  m_output << "(";
  425|  8.56k|  visit(x.tern_cond());
  426|  8.56k|  m_output << " ? ";
  427|  8.56k|  visit(x.t_branch());
  428|  8.56k|  m_output << " : ";
  429|  8.56k|  visit(x.f_branch());
  430|  8.56k|  m_output << ")\n";
  431|  8.56k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_4TimeE:
  434|  10.2k|{
  435|  10.2k|  switch (x.t_func()) {
  ------------------
  |  Branch (435:11): [True: 0, False: 10.2k]
  ------------------
  436|  5.03k|    case Time::AT:
  ------------------
  |  Branch (436:5): [True: 5.03k, False: 5.22k]
  ------------------
  437|  5.03k|      m_output << "Time.at";
  438|  5.03k|      break;
  439|  5.22k|    case Time::GM:
  ------------------
  |  Branch (439:5): [True: 5.22k, False: 5.03k]
  ------------------
  440|  5.22k|      m_output << "Time.gm";
  441|  5.22k|      break;
  442|  10.2k|  }
  443|  10.2k|  m_output << "(" << (x.t_arg()% 13) << ")" << "\n";
  444|  10.2k|}
_ZN11ruby_fuzzer14protoConverter5visitERKNS_6VarRefE:
  447|  72.8k|{
  448|  72.8k|  m_output << "var_" << (static_cast<uint32_t>(x.varnum()) % m_numLiveVars);
  449|  72.8k|}
_ZN11ruby_fuzzer14protoConverter16FunctionToStringERKNS_8FunctionE:
  452|  1.74k|{
  453|  1.74k|  visit(input);
  454|  1.74k|  return m_output.str();
  455|  1.74k|}
proto_to_ruby.cpp:_ZZN11ruby_fuzzer14protoConverter13removeSpecialERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENK3$_0clEc:
   10|  5.36M|                             [](char c) { return !(std::isalpha(c) || std::isdigit(c)); } ), tmp.end());
  ------------------
  |  Branch (10:52): [True: 4.77M, False: 594k]
  |  Branch (10:71): [True: 98.8k, False: 495k]
  ------------------

_ZN11ruby_fuzzer14protoConverterC2Ev:
   13|  1.74k|    protoConverter() {
   14|  1.74k|      m_numLiveVars = 1;
   15|  1.74k|      m_numVarsPerScope.push(m_numLiveVars);
   16|  1.74k|    }
_ZN11ruby_fuzzer14protoConverterD2Ev:
   21|  1.74k|    ~protoConverter() {}

mrb_ary_new_capa:
   66|  94.9k|{
   67|  94.9k|  struct RArray *a = ary_new_capa(mrb, capa);
   68|  94.9k|  return mrb_obj_value(a);
   69|  94.9k|}
mrb_ary_new:
   73|    755|{
   74|    755|  return mrb_ary_new_capa(mrb, 0);
   75|    755|}
mrb_ary_new_from_values:
  113|   138k|{
  114|   138k|  struct RArray *a = ary_new_from_values(mrb, size, vals);
  115|   138k|  return mrb_obj_value(a);
  116|   138k|}
mrb_ary_modify:
  177|    697|{
  178|    697|  mrb_write_barrier(mrb, (struct RBasic*)a);
  179|    697|  ary_modify(mrb, a);
  180|    697|}
mrb_ary_concat:
  332|  24.8k|{
  333|  24.8k|  struct RArray *a2 = mrb_ary_ptr(other);
  ------------------
  |  |   51|  24.8k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  24.8k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  334|       |
  335|  24.8k|  ary_concat(mrb, mrb_ary_ptr(self), a2);
  ------------------
  |  |   51|  24.8k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  24.8k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  336|  24.8k|}
mrb_ary_replace:
  428|  11.3k|{
  429|  11.3k|  struct RArray *a1 = mrb_ary_ptr(self);
  ------------------
  |  |   51|  11.3k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  11.3k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  430|  11.3k|  struct RArray *a2 = mrb_ary_ptr(other);
  ------------------
  |  |   51|  11.3k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  11.3k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  431|       |
  432|  11.3k|  if (a1 != a2) {
  ------------------
  |  Branch (432:7): [True: 11.3k, False: 0]
  ------------------
  433|  11.3k|    ary_replace(mrb, a1, a2);
  434|  11.3k|  }
  435|  11.3k|}
mrb_ary_push:
  526|   272k|{
  527|   272k|  struct RArray *a = mrb_ary_ptr(ary);
  ------------------
  |  |   51|   272k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   272k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  528|   272k|  mrb_int len = ARY_LEN(a);
  ------------------
  |  |   70|   272k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|   272k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   272k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 115k, False: 156k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|   115k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   115k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  529|       |
  530|   272k|  ary_modify(mrb, a);
  531|   272k|  if (len == ARY_CAPA(a))
  ------------------
  |  |   82|   272k|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|   272k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   272k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 115k, False: 156k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|   115k|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (531:7): [True: 2.72k, False: 269k]
  ------------------
  532|  2.72k|    ary_expand_capa(mrb, a, len + 1);
  533|   272k|  ARY_PTR(a)[len] = elem;
  ------------------
  |  |   71|   272k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|   272k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   272k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 114k, False: 158k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|   114k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  534|   272k|  ARY_SET_LEN(a, len+1);
  ------------------
  |  |   74|   272k|#define ARY_SET_LEN(a,n) do {\
  |  |   75|   272k|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|   272k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   272k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 114k, False: 158k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|   114k|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|   114k|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|   114k|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|   114k|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   114k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|   114k|  }\
  |  |   79|   272k|  else\
  |  |   80|   272k|    (a)->as.heap.len = (n);\
  |  |   81|   272k|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  535|   272k|  mrb_field_write_barrier_value(mrb, (struct RBasic*)a, elem);
  ------------------
  |  | 1317|   272k|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|   272k|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|   272k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   544k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 247k, False: 25.1k]
  |  |  |  |  |  Branch (148:63): [True: 271, False: 24.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|  24.8k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  24.8k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|   272k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  536|   272k|}
mrb_ary_set:
  751|  13.0k|{
  752|  13.0k|  struct RArray *a = mrb_ary_ptr(ary);
  ------------------
  |  |   51|  13.0k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  13.0k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  753|  13.0k|  mrb_int len = ARY_LEN(a);
  ------------------
  |  |   70|  13.0k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  13.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  13.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 752, False: 12.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|    752|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    752|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  754|       |
  755|  13.0k|  ary_modify(mrb, a);
  756|       |  /* range check */
  757|  13.0k|  if (n < 0) {
  ------------------
  |  Branch (757:7): [True: 0, False: 13.0k]
  ------------------
  758|      0|    n += len;
  759|      0|    if (n < 0) {
  ------------------
  |  Branch (759:9): [True: 0, False: 0]
  ------------------
  760|      0|      mrb_raisef(mrb, E_INDEX_ERROR, "index %i out of array", n - len);
  ------------------
  |  | 1378|      0|#define E_INDEX_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(IndexError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  761|      0|    }
  762|      0|  }
  763|  13.0k|  if (n >= ARY_MAX_SIZE) {
  ------------------
  |  |   23|  13.0k|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  13.0k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|  13.0k|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  13.0k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (763:7): [True: 0, False: 13.0k]
  ------------------
  764|      0|    mrb_raise(mrb, E_INDEX_ERROR, "index too big");
  ------------------
  |  | 1378|      0|#define E_INDEX_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(IndexError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  765|      0|  }
  766|  13.0k|  if (len <= n) {
  ------------------
  |  Branch (766:7): [True: 0, False: 13.0k]
  ------------------
  767|      0|    if (ARY_CAPA(a) <= n)
  ------------------
  |  |   82|      0|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|      0|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (767:9): [True: 0, False: 0]
  ------------------
  768|      0|      ary_expand_capa(mrb, a, n + 1);
  769|      0|    ary_fill_with_nil(ARY_PTR(a) + len, n + 1 - len);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  770|      0|    ARY_SET_LEN(a, n+1);
  ------------------
  |  |   74|      0|#define ARY_SET_LEN(a,n) do {\
  |  |   75|      0|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|      0|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|      0|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|  }\
  |  |   79|      0|  else\
  |  |   80|      0|    (a)->as.heap.len = (n);\
  |  |   81|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  771|      0|  }
  772|       |
  773|  13.0k|  ARY_PTR(a)[n] = val;
  ------------------
  |  |   71|  13.0k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  13.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  13.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 752, False: 12.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|    752|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  774|  13.0k|  mrb_field_write_barrier_value(mrb, (struct RBasic*)a, val);
  ------------------
  |  | 1317|  13.0k|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|  13.0k|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|  13.0k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  26.0k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 2.78k, False: 10.2k]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 10.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|  10.2k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  10.2k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|  13.0k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  775|  13.0k|}
mrb_ary_splice:
  785|  2.83k|{
  786|  2.83k|  struct RArray *a = mrb_ary_ptr(ary);
  ------------------
  |  |   51|  2.83k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  2.83k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  787|  2.83k|  mrb_int alen = ARY_LEN(a);
  ------------------
  |  |   70|  2.83k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  2.83k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.83k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 2.56k, False: 269]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  2.56k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.56k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  788|  2.83k|  const mrb_value *argv;
  789|  2.83k|  mrb_int argc;
  790|  2.83k|  mrb_int tail;
  791|       |
  792|  2.83k|  ary_modify(mrb, a);
  793|       |
  794|       |  /* len check */
  795|  2.83k|  if (len < 0) mrb_raisef(mrb, E_INDEX_ERROR, "negative length (%i)", len);
  ------------------
  |  | 1378|      0|#define E_INDEX_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(IndexError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (795:7): [True: 0, False: 2.83k]
  ------------------
  796|       |
  797|       |  /* range check */
  798|  2.83k|  if (head < 0) {
  ------------------
  |  Branch (798:7): [True: 32, False: 2.79k]
  ------------------
  799|     32|    head += alen;
  800|     32|    if (head < 0) goto out_of_range;
  ------------------
  |  Branch (800:9): [True: 0, False: 32]
  ------------------
  801|     32|  }
  802|  2.83k|  if (head > ARY_MAX_SIZE - len) {
  ------------------
  |  |   23|  2.83k|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  2.83k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|  2.83k|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  2.83k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (802:7): [True: 0, False: 2.83k]
  ------------------
  803|      0|  out_of_range:
  804|      0|    mrb_raisef(mrb, E_INDEX_ERROR, "index %i is out of array", head);
  ------------------
  |  | 1378|      0|#define E_INDEX_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(IndexError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  805|      0|  }
  806|  2.83k|  tail = head + len;
  807|  2.83k|  if (alen < len || alen < tail) {
  ------------------
  |  Branch (807:7): [True: 0, False: 2.83k]
  |  Branch (807:21): [True: 423, False: 2.40k]
  ------------------
  808|    423|    len = alen - head;
  809|    423|    tail = head + len;
  810|    423|  }
  811|       |
  812|       |  /* size check */
  813|  2.83k|  if (mrb_array_p(rpl)) {
  ------------------
  |  |  186|  2.83k|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|  2.83k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  5.66k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  5.66k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 2.83k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 2.83k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 2.83k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  814|  2.83k|    argc = RARRAY_LEN(rpl);
  ------------------
  |  |   72|  2.83k|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|  2.83k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  2.83k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  2.83k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 2.83k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|  2.83k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  2.83k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  815|  2.83k|    argv = RARRAY_PTR(rpl);
  ------------------
  |  |   73|  2.83k|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|  2.83k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  2.83k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  2.83k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 2.83k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|  2.83k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  816|  2.83k|    if (argv == ARY_PTR(a)) {
  ------------------
  |  |   71|  2.83k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  2.83k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.83k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 2.56k, False: 269]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  2.56k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  |  Branch (816:9): [True: 0, False: 2.83k]
  ------------------
  817|      0|      struct RArray *r;
  818|       |
  819|      0|      if (argc > 32767) {
  ------------------
  |  Branch (819:11): [True: 0, False: 0]
  ------------------
  820|      0|        mrb_raise(mrb, E_ARGUMENT_ERROR, "too big recursive splice");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  821|      0|      }
  822|      0|      r = ary_dup(mrb, a);
  823|      0|      argv = ARY_PTR(r);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  824|      0|    }
  825|  2.83k|  }
  826|      0|  else if (mrb_undef_p(rpl)) {
  ------------------
  |  |  173|      0|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  827|      0|    argc = 0;
  828|      0|    argv = NULL;
  829|      0|  }
  830|      0|  else {
  831|      0|    argc = 1;
  832|      0|    argv = &rpl;
  833|      0|  }
  834|  2.83k|  if (head >= alen) {
  ------------------
  |  Branch (834:7): [True: 2.32k, False: 503]
  ------------------
  835|  2.32k|    if (head > ARY_MAX_SIZE - argc) goto out_of_range;
  ------------------
  |  |   23|  2.32k|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  2.32k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|  2.32k|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  2.32k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (835:9): [True: 0, False: 2.32k]
  ------------------
  836|  2.32k|    len = head + argc;
  837|  2.32k|    if (len > ARY_CAPA(a)) {
  ------------------
  |  |   82|  2.32k|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|  2.32k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.32k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 2.30k, False: 19]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|  2.30k|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (837:9): [True: 422, False: 1.90k]
  ------------------
  838|    422|      ary_expand_capa(mrb, a, len);
  839|    422|    }
  840|  2.32k|    ary_fill_with_nil(ARY_PTR(a) + alen, head - alen);
  ------------------
  |  |   71|  2.32k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  2.32k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.32k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 1.90k, False: 425]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  1.90k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  841|  2.32k|    if (argc > 0) {
  ------------------
  |  Branch (841:9): [True: 0, False: 2.32k]
  ------------------
  842|      0|      array_copy(ARY_PTR(a) + head, argv, argc);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  843|      0|    }
  844|  2.32k|    ARY_SET_LEN(a, len);
  ------------------
  |  |   74|  2.32k|#define ARY_SET_LEN(a,n) do {\
  |  |   75|  2.32k|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|  2.32k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.32k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 1.90k, False: 425]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|  1.90k|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|  1.90k|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|  1.90k|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|  1.90k|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  1.90k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|  1.90k|  }\
  |  |   79|  2.32k|  else\
  |  |   80|  2.32k|    (a)->as.heap.len = (n);\
  |  |   81|  2.32k|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  845|  2.32k|  }
  846|    503|  else {
  847|    503|    mrb_int newlen;
  848|       |
  849|    503|    if (alen - len > ARY_MAX_SIZE - argc) {
  ------------------
  |  |   23|    503|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|    503|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|    503|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|    503|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (849:9): [True: 0, False: 503]
  ------------------
  850|      0|      head = alen + argc - len;
  851|      0|      goto out_of_range;
  852|      0|    }
  853|    503|    newlen = alen + argc - len;
  854|    503|    if (newlen > ARY_CAPA(a)) {
  ------------------
  |  |   82|    503|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|    503|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    503|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 253, False: 250]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|    253|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (854:9): [True: 0, False: 503]
  ------------------
  855|      0|      ary_expand_capa(mrb, a, newlen);
  856|      0|    }
  857|       |
  858|    503|    if (len != argc) {
  ------------------
  |  Branch (858:9): [True: 0, False: 503]
  ------------------
  859|      0|      mrb_value *ptr = ARY_PTR(a);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  860|      0|      value_move(ptr + head + argc, ptr + tail, alen - tail);
  861|      0|      ARY_SET_LEN(a, newlen);
  ------------------
  |  |   74|      0|#define ARY_SET_LEN(a,n) do {\
  |  |   75|      0|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|      0|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|      0|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|  }\
  |  |   79|      0|  else\
  |  |   80|      0|    (a)->as.heap.len = (n);\
  |  |   81|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  862|      0|    }
  863|    503|    if (argc > 0) {
  ------------------
  |  Branch (863:9): [True: 0, False: 503]
  ------------------
  864|      0|      value_move(ARY_PTR(a) + head, argv, argc);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  865|      0|    }
  866|    503|  }
  867|  2.83k|  mrb_write_barrier(mrb, (struct RBasic*)a);
  868|  2.83k|  return ary;
  869|  2.83k|}
mrb_ary_decref:
  873|    590|{
  874|    590|  shared->refcnt--;
  875|    590|  if (shared->refcnt == 0) {
  ------------------
  |  Branch (875:7): [True: 295, False: 295]
  ------------------
  876|    295|    mrb_free(mrb, shared->ptr);
  877|    295|    mrb_free(mrb, shared);
  878|    295|  }
  879|    590|}
mrb_ary_splat:
 1166|  47.5k|{
 1167|  47.5k|  mrb_value ary;
 1168|  47.5k|  struct RArray *a;
 1169|       |
 1170|  47.5k|  if (mrb_array_p(v)) {
  ------------------
  |  |  186|  47.5k|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|  47.5k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  95.1k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  95.1k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 47.5k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 47.5k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 47.5k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1171|  47.5k|    a = ary_dup(mrb, mrb_ary_ptr(v));
  ------------------
  |  |   51|  47.5k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  47.5k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1172|  47.5k|    return mrb_obj_value(a);
 1173|  47.5k|  }
 1174|       |
 1175|      0|  if (!mrb_respond_to(mrb, v, MRB_SYM(to_a))) {
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  |  Branch (1175:7): [True: 0, False: 0]
  ------------------
 1176|      0|    return mrb_ary_new_from_values(mrb, 1, &v);
 1177|      0|  }
 1178|       |
 1179|      0|  ary = mrb_funcall_id(mrb, v, MRB_SYM(to_a), 0);
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 1180|      0|  if (mrb_nil_p(ary)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1181|      0|    return mrb_ary_new_from_values(mrb, 1, &v);
 1182|      0|  }
 1183|      0|  mrb_ensure_array_type(mrb, ary);
 1184|      0|  a = mrb_ary_ptr(ary);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1185|      0|  a = ary_dup(mrb, a);
 1186|      0|  return mrb_obj_value(a);
 1187|      0|}
mrb_ary_entry:
 1237|  58.4k|{
 1238|  58.4k|  struct RArray *a = mrb_ary_ptr(ary);
  ------------------
  |  |   51|  58.4k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  58.4k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1239|  58.4k|  mrb_int len = ARY_LEN(a);
  ------------------
  |  |   70|  58.4k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  58.4k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  58.4k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 28.3k, False: 30.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  28.3k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  28.3k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1240|       |
 1241|       |  /* range check */
 1242|  58.4k|  if (n < 0) n += len;
  ------------------
  |  Branch (1242:7): [True: 341, False: 58.0k]
  ------------------
 1243|  58.4k|  if (n < 0 || len <= n) return mrb_nil_value();
  ------------------
  |  Branch (1243:7): [True: 334, False: 58.0k]
  |  Branch (1243:16): [True: 3.73k, False: 54.3k]
  ------------------
 1244|       |
 1245|  54.3k|  return ARY_PTR(a)[n];
  ------------------
  |  |   71|  54.3k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  54.3k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  54.3k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.3k, False: 30.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  24.3k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 1246|  58.4k|}
mrb_init_array:
 1379|  1.74k|{
 1380|  1.74k|  struct RClass *a;
 1381|       |
 1382|  1.74k|  mrb->array_class = a = mrb_define_class(mrb, "Array", mrb->object_class);              /* 15.2.12 */
 1383|  1.74k|  MRB_SET_INSTANCE_TT(a, MRB_TT_ARRAY);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 1384|       |
 1385|  1.74k|  mrb_define_class_method(mrb, a, "[]",        mrb_ary_s_create,     MRB_ARGS_ANY());    /* 15.2.12.4.1 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1386|       |
 1387|  1.74k|  mrb_define_method(mrb, a, "+",               mrb_ary_plus,         MRB_ARGS_REQ(1));   /* 15.2.12.5.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1388|  1.74k|  mrb_define_method(mrb, a, "*",               mrb_ary_times,        MRB_ARGS_REQ(1));   /* 15.2.12.5.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1389|  1.74k|  mrb_define_method(mrb, a, "<<",              mrb_ary_push_m,       MRB_ARGS_REQ(1));   /* 15.2.12.5.3  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1390|  1.74k|  mrb_define_method(mrb, a, "[]",              mrb_ary_aget,         MRB_ARGS_ARG(1,1)); /* 15.2.12.5.4  */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1391|  1.74k|  mrb_define_method(mrb, a, "[]=",             mrb_ary_aset,         MRB_ARGS_ARG(2,1)); /* 15.2.12.5.5  */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1392|  1.74k|  mrb_define_method(mrb, a, "clear",           mrb_ary_clear_m,      MRB_ARGS_NONE());   /* 15.2.12.5.6  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1393|  1.74k|  mrb_define_method(mrb, a, "concat",          mrb_ary_concat_m,     MRB_ARGS_REQ(1));   /* 15.2.12.5.8  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1394|  1.74k|  mrb_define_method(mrb, a, "delete_at",       mrb_ary_delete_at,    MRB_ARGS_REQ(1));   /* 15.2.12.5.9  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1395|  1.74k|  mrb_define_method(mrb, a, "empty?",          mrb_ary_empty_p,      MRB_ARGS_NONE());   /* 15.2.12.5.12 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1396|  1.74k|  mrb_define_method(mrb, a, "first",           mrb_ary_first,        MRB_ARGS_OPT(1));   /* 15.2.12.5.13 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1397|  1.74k|  mrb_define_method(mrb, a, "index",           mrb_ary_index_m,      MRB_ARGS_REQ(1));   /* 15.2.12.5.14 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1398|  1.74k|  mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m,    MRB_ARGS_REQ(1));   /* 15.2.12.5.16 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1399|  1.74k|  mrb_define_method(mrb, a, "join",            mrb_ary_join_m,       MRB_ARGS_OPT(1));   /* 15.2.12.5.17 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1400|  1.74k|  mrb_define_method(mrb, a, "last",            mrb_ary_last,         MRB_ARGS_OPT(1));   /* 15.2.12.5.18 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1401|  1.74k|  mrb_define_method(mrb, a, "length",          mrb_ary_size,         MRB_ARGS_NONE());   /* 15.2.12.5.19 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1402|  1.74k|  mrb_define_method(mrb, a, "pop",             mrb_ary_pop,          MRB_ARGS_NONE());   /* 15.2.12.5.21 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1403|  1.74k|  mrb_define_method(mrb, a, "push",            mrb_ary_push_m,       MRB_ARGS_ANY());    /* 15.2.12.5.22 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1404|  1.74k|  mrb_define_method(mrb, a, "replace",         mrb_ary_replace_m,    MRB_ARGS_REQ(1));   /* 15.2.12.5.23 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1405|  1.74k|  mrb_define_method(mrb, a, "reverse",         mrb_ary_reverse,      MRB_ARGS_NONE());   /* 15.2.12.5.24 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1406|  1.74k|  mrb_define_method(mrb, a, "reverse!",        mrb_ary_reverse_bang, MRB_ARGS_NONE());   /* 15.2.12.5.25 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1407|  1.74k|  mrb_define_method(mrb, a, "rindex",          mrb_ary_rindex_m,     MRB_ARGS_REQ(1));   /* 15.2.12.5.26 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1408|  1.74k|  mrb_define_method(mrb, a, "shift",           mrb_ary_shift_m,      MRB_ARGS_OPT(1));   /* 15.2.12.5.27 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1409|  1.74k|  mrb_define_method(mrb, a, "size",            mrb_ary_size,         MRB_ARGS_NONE());   /* 15.2.12.5.28 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1410|  1.74k|  mrb_define_method(mrb, a, "slice",           mrb_ary_aget,         MRB_ARGS_ARG(1,1)); /* 15.2.12.5.29 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 1411|  1.74k|  mrb_define_method(mrb, a, "unshift",         mrb_ary_unshift_m,    MRB_ARGS_ANY());    /* 15.2.12.5.30 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 1412|       |
 1413|  1.74k|  mrb_define_method(mrb, a, "__ary_eq",        mrb_ary_eq,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1414|  1.74k|  mrb_define_method(mrb, a, "__ary_cmp",       mrb_ary_cmp,          MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1415|  1.74k|  mrb_define_method(mrb, a, "__ary_index",     mrb_ary_index_m,      MRB_ARGS_REQ(1));   /* kept for mruby-array-ext */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1416|  1.74k|  mrb_define_method(mrb, a, "__svalue",        mrb_ary_svalue,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1417|  1.74k|}
array.c:ary_new_capa:
   44|   280k|{
   45|   280k|  struct RArray *a;
   46|   280k|  size_t blen;
   47|       |
   48|   280k|  ary_check_too_big(mrb, capa, 0);
   49|   280k|  blen = capa * sizeof(mrb_value);
   50|       |
   51|   280k|  a = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class);
  ------------------
  |  | 1200|   280k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
   52|   280k|  if (capa <= MRB_ARY_EMBED_LEN_MAX) {
  ------------------
  |  |   30|   280k|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  ------------------
  |  Branch (52:7): [True: 271k, False: 9.14k]
  ------------------
   53|   271k|    ARY_SET_EMBED_LEN(a, 0);
  ------------------
  |  |   66|   271k|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  ------------------
  |  |  |  |   62|   271k|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  ------------------
   54|   271k|  }
   55|  9.14k|  else {
   56|  9.14k|    a->as.heap.ptr = (mrb_value *)mrb_malloc(mrb, blen);
   57|  9.14k|    a->as.heap.aux.capa = capa;
   58|  9.14k|    a->as.heap.len = 0;
   59|  9.14k|  }
   60|       |
   61|   280k|  return a;
   62|   280k|}
array.c:ary_check_too_big:
   33|   320k|{
   34|   320k|  if (a > ARY_MAX_SIZE - b || a < 0)
  ------------------
  |  |   23|   320k|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|   320k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|   320k|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|   320k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (34:7): [True: 0, False: 320k]
  |  Branch (34:31): [True: 0, False: 320k]
  ------------------
   35|      0|    ary_too_big(mrb);
   36|   320k|#if MRB_ARY_LENGTH_MAX != 0
   37|   320k|  if (a > MRB_ARY_LENGTH_MAX - b || a < 0)
  ------------------
  |  |   21|   320k|#define MRB_ARY_LENGTH_MAX 131072
  ------------------
  |  Branch (37:7): [True: 4, False: 320k]
  |  Branch (37:37): [True: 0, False: 320k]
  ------------------
   38|      4|    ary_too_big(mrb);
   39|   320k|#endif
   40|   320k|}
array.c:ary_too_big:
   27|      4|{
   28|      4|  mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
  ------------------
  |  | 1377|      4|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      4|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      4|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   29|      4|}
array.c:ary_new_from_values:
  102|   186k|{
  103|   186k|  struct RArray *a = ary_new_capa(mrb, size);
  104|       |
  105|   186k|  array_copy(ARY_PTR(a), vals, size);
  ------------------
  |  |   71|   186k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|   186k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   186k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 179k, False: 6.98k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|   179k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  106|   186k|  ARY_SET_LEN(a, size);
  ------------------
  |  |   74|   186k|#define ARY_SET_LEN(a,n) do {\
  |  |   75|   186k|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|   186k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   186k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 179k, False: 6.98k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|   179k|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|   179k|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|   179k|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|   179k|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   179k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|   179k|  }\
  |  |   79|   186k|  else\
  |  |   80|   186k|    (a)->as.heap.len = (n);\
  |  |   81|   186k|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|       |
  108|   186k|  return a;
  109|   186k|}
array.c:ary_modify:
  146|   313k|{
  147|   313k|  ary_modify_check(mrb, a);
  ------------------
  |  |  142|   313k|#define ary_modify_check(mrb, a) mrb_check_frozen((mrb), (a))
  ------------------
  148|       |
  149|   313k|  if (ARY_SHARED_P(a)) {
  ------------------
  |  |   84|   313k|#define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|   313k|#define MRB_ARY_SHARED      256
  |  |  ------------------
  |  |  |  Branch (84:25): [True: 0, False: 313k]
  |  |  ------------------
  ------------------
  150|      0|    mrb_shared_array *shared = a->as.heap.aux.shared;
  151|       |
  152|      0|    if (shared->refcnt == 1 && a->as.heap.ptr == shared->ptr) {
  ------------------
  |  Branch (152:9): [True: 0, False: 0]
  |  Branch (152:32): [True: 0, False: 0]
  ------------------
  153|      0|      a->as.heap.ptr = shared->ptr;
  154|      0|      a->as.heap.aux.capa = a->as.heap.len;
  155|      0|      mrb_free(mrb, shared);
  156|      0|    }
  157|      0|    else {
  158|      0|      mrb_value *ptr, *p;
  159|      0|      mrb_int len;
  160|       |
  161|      0|      p = a->as.heap.ptr;
  162|      0|      len = a->as.heap.len * sizeof(mrb_value);
  163|      0|      ptr = (mrb_value*)mrb_malloc(mrb, len);
  164|      0|      if (p) {
  ------------------
  |  Branch (164:11): [True: 0, False: 0]
  ------------------
  165|      0|        array_copy(ptr, p, a->as.heap.len);
  166|      0|      }
  167|      0|      a->as.heap.ptr = ptr;
  168|      0|      a->as.heap.aux.capa = a->as.heap.len;
  169|      0|      mrb_ary_decref(mrb, shared);
  170|      0|    }
  171|      0|    ARY_UNSET_SHARED_FLAG(a);
  ------------------
  |  |   86|      0|#define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|      0|#define MRB_ARY_SHARED      256
  |  |  ------------------
  ------------------
  172|      0|  }
  173|   313k|}
array.c:ary_expand_capa:
  205|  14.1k|{
  206|  14.1k|  mrb_int capa = ARY_CAPA(a);
  ------------------
  |  |   82|  14.1k|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|  14.1k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  14.1k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 1.60k, False: 12.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|  1.60k|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  207|       |
  208|  14.1k|  ary_check_too_big(mrb, len, 0);
  209|  14.1k|  if (capa < ARY_DEFAULT_LEN) {
  ------------------
  |  |   17|  14.1k|#define ARY_DEFAULT_LEN   4
  ------------------
  |  Branch (209:7): [True: 12.6k, False: 1.54k]
  ------------------
  210|  12.6k|    capa = ARY_DEFAULT_LEN;
  ------------------
  |  |   17|  12.6k|#define ARY_DEFAULT_LEN   4
  ------------------
  211|  12.6k|  }
  212|  16.3k|  while (capa < len) {
  ------------------
  |  Branch (212:10): [True: 2.12k, False: 14.1k]
  ------------------
  213|  2.12k|    if (capa <= ARY_MAX_SIZE / 2) {
  ------------------
  |  |   23|  2.12k|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  2.12k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|  2.12k|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  2.12k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (213:9): [True: 2.12k, False: 0]
  ------------------
  214|  2.12k|      capa *= 2;
  215|  2.12k|    }
  216|      0|    else {
  217|      0|      capa = len;
  218|      0|    }
  219|  2.12k|  }
  220|  14.1k|  if (capa < len || capa > ARY_MAX_SIZE) {
  ------------------
  |  |   23|  14.1k|#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  14.1k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|  14.1k|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   19|  14.1k|#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
  |  |  ------------------
  |  |               #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
  |  |  ------------------
  |  |  |  |   82|      0|# define MRB_INT_MAX INT64_MAX
  |  |  ------------------
  |  |  |  Branch (23:33): [Folded - Ignored]
  |  |  ------------------
  ------------------
  |  Branch (220:7): [True: 4, False: 14.1k]
  |  Branch (220:21): [True: 0, False: 14.1k]
  ------------------
  221|      0|    ary_too_big(mrb);
  222|      0|  }
  223|       |
  224|  14.1k|  if (ARY_EMBED_P(a)) {
  ------------------
  |  |   63|  14.1k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  ------------------
  |  |  |  |   62|  14.1k|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  |  |  |  Branch (63:24): [True: 1.60k, False: 12.5k]
  |  |  ------------------
  ------------------
  225|  1.60k|    mrb_value *ptr = ARY_EMBED_PTR(a);
  ------------------
  |  |   67|  1.60k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  ------------------
  226|  1.60k|    mrb_int len = ARY_EMBED_LEN(a);
  ------------------
  |  |   65|  1.60k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  ------------------
  |  |  |  |   62|  1.60k|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  ------------------
  227|  1.60k|    mrb_value *expanded_ptr = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*capa);
  228|       |
  229|  1.60k|    ARY_UNSET_EMBED_FLAG(a);
  ------------------
  |  |   64|  1.60k|#define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
  |  |  ------------------
  |  |  |  |   62|  1.60k|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  ------------------
  230|  1.60k|    array_copy(expanded_ptr, ptr, len);
  231|  1.60k|    a->as.heap.len = len;
  232|  1.60k|    a->as.heap.aux.capa = capa;
  233|  1.60k|    a->as.heap.ptr = expanded_ptr;
  234|  1.60k|  }
  235|  12.5k|  else if (capa > a->as.heap.aux.capa) {
  ------------------
  |  Branch (235:12): [True: 12.5k, False: 4]
  ------------------
  236|  12.5k|    mrb_value *expanded_ptr = (mrb_value*)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
  237|       |
  238|  12.5k|    a->as.heap.aux.capa = capa;
  239|  12.5k|    a->as.heap.ptr = expanded_ptr;
  240|  12.5k|  }
  241|  14.1k|}
array.c:ary_fill_with_nil:
  134|  2.32k|{
  135|  2.32k|  mrb_value nil = mrb_nil_value();
  136|       |
  137|  4.62k|  while (size--) {
  ------------------
  |  Branch (137:10): [True: 2.29k, False: 2.32k]
  ------------------
  138|  2.29k|    *ptr++ = nil;
  139|  2.29k|  }
  140|  2.32k|}
array.c:ary_concat:
  311|  24.8k|{
  312|  24.8k|  mrb_int len;
  313|       |
  314|  24.8k|  if (ARY_LEN(a) == 0) {
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (314:7): [True: 0, False: 24.8k]
  ------------------
  315|      0|    ary_replace(mrb, a, a2);
  316|      0|    return;
  317|      0|  }
  318|  24.8k|  ary_check_too_big(mrb, ARY_LEN(a2), ARY_LEN(a));
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                ary_check_too_big(mrb, ARY_LEN(a2), ARY_LEN(a));
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  319|  24.8k|  len = ARY_LEN(a) + ARY_LEN(a2);
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                len = ARY_LEN(a) + ARY_LEN(a2);
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  320|       |
  321|  24.8k|  ary_modify(mrb, a);
  322|  24.8k|  if (ARY_CAPA(a) < len) {
  ------------------
  |  |   82|  24.8k|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|  24.8k|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (322:7): [True: 0, False: 24.8k]
  ------------------
  323|      0|    ary_expand_capa(mrb, a, len);
  324|      0|  }
  325|  24.8k|  array_copy(ARY_PTR(a)+ARY_LEN(a), ARY_PTR(a2), ARY_LEN(a2));
  ------------------
  |  |   71|  24.8k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  24.8k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
                array_copy(ARY_PTR(a)+ARY_LEN(a), ARY_PTR(a2), ARY_LEN(a2));
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                array_copy(ARY_PTR(a)+ARY_LEN(a), ARY_PTR(a2), ARY_LEN(a2));
  ------------------
  |  |   71|  24.8k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  24.8k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
                array_copy(ARY_PTR(a)+ARY_LEN(a), ARY_PTR(a2), ARY_LEN(a2));
  ------------------
  |  |   70|  24.8k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  24.8k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  326|  24.8k|  mrb_write_barrier(mrb, (struct RBasic*)a);
  327|  24.8k|  ARY_SET_LEN(a, len);
  ------------------
  |  |   74|  24.8k|#define ARY_SET_LEN(a,n) do {\
  |  |   75|  24.8k|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|  24.8k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 24.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|  24.8k|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|  24.8k|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|  24.8k|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|  24.8k|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  24.8k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|  24.8k|  }\
  |  |   79|  24.8k|  else\
  |  |   80|  24.8k|    (a)->as.heap.len = (n);\
  |  |   81|  24.8k|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  328|  24.8k|}
array.c:ary_replace:
  387|  11.3k|{
  388|  11.3k|  mrb_int len = ARY_LEN(b);
  ------------------
  |  |   70|  11.3k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  11.3k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  11.3k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 10.2k, False: 1.09k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  10.2k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  10.2k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  389|       |
  390|  11.3k|  ary_modify_check(mrb, a);
  ------------------
  |  |  142|  11.3k|#define ary_modify_check(mrb, a) mrb_check_frozen((mrb), (a))
  ------------------
  391|  11.3k|  if (a == b) return;
  ------------------
  |  Branch (391:7): [True: 0, False: 11.3k]
  ------------------
  392|  11.3k|  if (ARY_SHARED_P(a)) {
  ------------------
  |  |   84|  11.3k|#define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|  11.3k|#define MRB_ARY_SHARED      256
  |  |  ------------------
  |  |  |  Branch (84:25): [True: 0, False: 11.3k]
  |  |  ------------------
  ------------------
  393|      0|    mrb_ary_decref(mrb, a->as.heap.aux.shared);
  394|      0|    a->as.heap.aux.capa = 0;
  395|      0|    a->as.heap.len = 0;
  396|      0|    a->as.heap.ptr = NULL;
  397|      0|    ARY_UNSET_SHARED_FLAG(a);
  ------------------
  |  |   86|      0|#define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|      0|#define MRB_ARY_SHARED      256
  |  |  ------------------
  ------------------
  398|      0|  }
  399|  11.3k|  if (ARY_SHARED_P(b)) {
  ------------------
  |  |   84|  11.3k|#define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|  11.3k|#define MRB_ARY_SHARED      256
  |  |  ------------------
  |  |  |  Branch (84:25): [True: 0, False: 11.3k]
  |  |  ------------------
  ------------------
  400|    295|  shared_b:
  401|    295|    if (ARY_EMBED_P(a)) {
  ------------------
  |  |   63|    295|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  ------------------
  |  |  |  |   62|    295|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  |  |  |  Branch (63:24): [True: 0, False: 295]
  |  |  ------------------
  ------------------
  402|      0|      ARY_UNSET_EMBED_FLAG(a);
  ------------------
  |  |   64|      0|#define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
  |  |  ------------------
  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  ------------------
  403|      0|    }
  404|    295|    else {
  405|    295|      mrb_free(mrb, a->as.heap.ptr);
  406|    295|    }
  407|    295|    a->as.heap.ptr = b->as.heap.ptr;
  408|    295|    a->as.heap.len = len;
  409|    295|    a->as.heap.aux.shared = b->as.heap.aux.shared;
  410|    295|    a->as.heap.aux.shared->refcnt++;
  411|    295|    ARY_SET_SHARED_FLAG(a);
  ------------------
  |  |   85|    295|#define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|    295|#define MRB_ARY_SHARED      256
  |  |  ------------------
  ------------------
  412|    295|    mrb_write_barrier(mrb, (struct RBasic*)a);
  413|    295|    return;
  414|      0|  }
  415|  11.3k|  if (!mrb_frozen_p(b) && len > ARY_REPLACE_SHARED_MIN) {
  ------------------
  |  |   28|  11.3k|#define mrb_frozen_p(o) MRB_FROZEN_P(o)
  |  |  ------------------
  |  |  |  |   25|  22.6k|#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
  |  |  |  |  ------------------
  |  |  |  |  |  |   24|  11.3k|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (!mrb_frozen_p(b) && len > ARY_REPLACE_SHARED_MIN) {
  ------------------
  |  |  383|  11.3k|#define ARY_REPLACE_SHARED_MIN 20
  ------------------
  |  Branch (415:7): [True: 11.3k, False: 0]
  |  Branch (415:27): [True: 295, False: 11.0k]
  ------------------
  416|    295|    ary_make_shared(mrb, b);
  417|    295|    goto shared_b;
  418|    295|  }
  419|  11.0k|  if (ARY_CAPA(a) < len)
  ------------------
  |  |   82|  11.0k|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|  11.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  11.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 11.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|      0|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (419:7): [True: 11.0k, False: 0]
  ------------------
  420|  11.0k|    ary_expand_capa(mrb, a, len);
  421|  11.0k|  array_copy(ARY_PTR(a), ARY_PTR(b), len);
  ------------------
  |  |   71|  11.0k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  11.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  11.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 11.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
                array_copy(ARY_PTR(a), ARY_PTR(b), len);
  ------------------
  |  |   71|  11.0k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  11.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  11.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 10.2k, False: 796]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  10.2k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  422|  11.0k|  mrb_write_barrier(mrb, (struct RBasic*)a);
  423|  11.0k|  ARY_SET_LEN(a, len);
  ------------------
  |  |   74|  11.0k|#define ARY_SET_LEN(a,n) do {\
  |  |   75|  11.0k|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|  11.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  11.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 11.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|      0|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|      0|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|  }\
  |  |   79|  11.0k|  else\
  |  |   80|  11.0k|    (a)->as.heap.len = (n);\
  |  |   81|  11.0k|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  424|  11.0k|}
array.c:ary_make_shared:
  184|    295|{
  185|    295|  if (!ARY_SHARED_P(a) && !ARY_EMBED_P(a)) {
  ------------------
  |  |   84|    590|#define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|    295|#define MRB_ARY_SHARED      256
  |  |  ------------------
  ------------------
                if (!ARY_SHARED_P(a) && !ARY_EMBED_P(a)) {
  ------------------
  |  |   63|    295|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  ------------------
  |  |  |  |   62|    295|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  ------------------
  |  Branch (185:7): [True: 295, False: 0]
  |  Branch (185:27): [True: 295, False: 0]
  ------------------
  186|    295|    mrb_shared_array *shared = (mrb_shared_array*)mrb_malloc(mrb, sizeof(mrb_shared_array));
  187|    295|    mrb_value *ptr = a->as.heap.ptr;
  188|    295|    mrb_int len = a->as.heap.len;
  189|       |
  190|    295|    shared->refcnt = 1;
  191|    295|    if (a->as.heap.aux.capa > len) {
  ------------------
  |  Branch (191:9): [True: 89, False: 206]
  ------------------
  192|     89|      a->as.heap.ptr = shared->ptr = (mrb_value*)mrb_realloc(mrb, ptr, sizeof(mrb_value)*len+1);
  193|     89|    }
  194|    206|    else {
  195|    206|      shared->ptr = ptr;
  196|    206|    }
  197|    295|    shared->len = len;
  198|    295|    a->as.heap.aux.shared = shared;
  199|    295|    ARY_SET_SHARED_FLAG(a);
  ------------------
  |  |   85|    295|#define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|    295|#define MRB_ARY_SHARED      256
  |  |  ------------------
  ------------------
  200|    295|  }
  201|    295|}
array.c:ary_dup:
  779|  47.5k|{
  780|  47.5k|  return ary_new_from_values(mrb, ARY_LEN(a), ARY_PTR(a));
  ------------------
  |  |   70|  47.5k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  47.5k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  47.5k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 44.0k, False: 3.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  44.0k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  44.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                return ary_new_from_values(mrb, ARY_LEN(a), ARY_PTR(a));
  ------------------
  |  |   71|  47.5k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  47.5k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  47.5k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 44.0k, False: 3.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  44.0k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  781|  47.5k|}
array.c:array_copy:
   92|   223k|{
   93|   223k|  mrb_int i;
   94|       |
   95|   539k|  for (i = 0; i < size; i++) {
  ------------------
  |  Branch (95:15): [True: 315k, False: 223k]
  ------------------
   96|   315k|    dst[i] = src[i];
   97|   315k|  }
   98|   223k|}
array.c:mrb_ary_push_m:
  540|  29.5k|{
  541|  29.5k|  mrb_int argc;
  542|  29.5k|  const mrb_value *argv;
  543|  29.5k|  mrb_int len, len2;
  544|  29.5k|  struct RArray *a;
  545|       |
  546|  29.5k|  argc = mrb_get_argc(mrb);
  547|  29.5k|  if (argc == 1) {
  ------------------
  |  Branch (547:7): [True: 29.5k, False: 0]
  ------------------
  548|  29.5k|    mrb_ary_push(mrb, self, mrb_get_argv(mrb)[0]);
  549|  29.5k|    return self;
  550|  29.5k|  }
  551|      0|  a = mrb_ary_ptr(self);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  552|      0|  ary_modify(mrb, a);
  553|      0|  len = ARY_LEN(a);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  554|      0|  len2 = len + argc;
  555|      0|  if (ARY_CAPA(a) < len2) {
  ------------------
  |  |   82|      0|#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   30|      0|# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
  |  |  ------------------
  ------------------
  |  Branch (555:7): [True: 0, False: 0]
  ------------------
  556|      0|    ary_expand_capa(mrb, a, len2);
  557|      0|  }
  558|      0|  argv = mrb_get_argv(mrb);
  559|      0|  array_copy(ARY_PTR(a)+len, argv, argc);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  560|      0|  ARY_SET_LEN(a, len2);
  ------------------
  |  |   74|      0|#define ARY_SET_LEN(a,n) do {\
  |  |   75|      0|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|      0|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|      0|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|  }\
  |  |   79|      0|  else\
  |  |   80|      0|    (a)->as.heap.len = (n);\
  |  |   81|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  561|      0|  while (argc--) {
  ------------------
  |  Branch (561:10): [True: 0, False: 0]
  ------------------
  562|      0|    mrb_field_write_barrier_value(mrb, (struct RBasic*)a, *argv);
  ------------------
  |  | 1317|      0|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|      0|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|      0|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  563|      0|    argv++;
  564|      0|  }
  565|      0|  return self;
  566|  29.5k|}
array.c:mrb_ary_aget:
  956|  2.25k|{
  957|  2.25k|  struct RArray *a = mrb_ary_ptr(self);
  ------------------
  |  |   51|  2.25k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  2.25k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  958|  2.25k|  mrb_int i;
  959|  2.25k|  mrb_int len, alen;
  960|  2.25k|  mrb_value index;
  961|       |
  962|  2.25k|  if (mrb_get_argc(mrb) == 1) {
  ------------------
  |  Branch (962:7): [True: 2.25k, False: 0]
  ------------------
  963|  2.25k|    index = mrb_get_arg1(mrb);
  964|  2.25k|    switch (mrb_type(index)) {
  965|       |      /* a[n..m] */
  966|      0|    case MRB_TT_RANGE:
  ------------------
  |  Branch (966:5): [True: 0, False: 2.25k]
  ------------------
  967|      0|      if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) {
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                    if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) {
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (967:11): [True: 0, False: 0]
  ------------------
  968|      0|        return ary_subseq(mrb, a, i, len);
  969|      0|      }
  970|      0|      else {
  971|      0|        return mrb_nil_value();
  972|      0|      }
  973|  1.37k|    case MRB_TT_INTEGER:
  ------------------
  |  Branch (973:5): [True: 1.37k, False: 874]
  ------------------
  974|  1.37k|      return mrb_ary_ref(mrb, self, mrb_integer(index));
  ------------------
  |  |  231|  1.37k|#define mrb_ary_ref(mrb, ary, n) mrb_ary_entry(ary, n)
  ------------------
  975|    874|    default:
  ------------------
  |  Branch (975:5): [True: 874, False: 1.37k]
  ------------------
  976|    874|      return mrb_ary_ref(mrb, self, aget_index(mrb, index));
  ------------------
  |  |  231|    874|#define mrb_ary_ref(mrb, ary, n) mrb_ary_entry(ary, n)
  ------------------
  977|  2.25k|    }
  978|  2.25k|  }
  979|       |
  980|      0|  mrb_get_args(mrb, "oi", &index, &len);
  981|      0|  i = aget_index(mrb, index);
  982|      0|  alen = ARY_LEN(a);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  983|      0|  if (i < 0) i += alen;
  ------------------
  |  Branch (983:7): [True: 0, False: 0]
  ------------------
  984|      0|  if (i < 0 || alen < i) return mrb_nil_value();
  ------------------
  |  Branch (984:7): [True: 0, False: 0]
  |  Branch (984:16): [True: 0, False: 0]
  ------------------
  985|      0|  if (len < 0) return mrb_nil_value();
  ------------------
  |  Branch (985:7): [True: 0, False: 0]
  ------------------
  986|      0|  if (alen == i) return mrb_ary_new(mrb);
  ------------------
  |  Branch (986:7): [True: 0, False: 0]
  ------------------
  987|      0|  if (len > alen - i) len = alen - i;
  ------------------
  |  Branch (987:7): [True: 0, False: 0]
  ------------------
  988|       |
  989|      0|  return ary_subseq(mrb, a, i, len);
  990|      0|}
array.c:aget_index:
  909|  19.5k|{
  910|  19.5k|  if (mrb_integer_p(index)) {
  ------------------
  |  |  171|  19.5k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  39.1k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 18.6k, False: 943]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|    943|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  1.88k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  1.88k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 943, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  911|  18.6k|    return mrb_integer(index);
  ------------------
  |  |  166|  18.6k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  912|  18.6k|  }
  913|    943|#ifndef MRB_NO_FLOAT
  914|    943|  else if (mrb_float_p(index)) {
  ------------------
  |  |  179|    943|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|    943|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 942, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  915|    942|    return (mrb_int)mrb_float(index);
  ------------------
  |  |  155|    942|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  916|    942|  }
  917|      1|#endif
  918|      1|  else {
  919|      1|    mrb_int i, argc;
  920|      1|    const mrb_value *argv;
  921|       |
  922|      1|    mrb_get_args(mrb, "i*!", &i, &argv, &argc);
  923|      1|    return i;
  924|      1|  }
  925|  19.5k|}
array.c:mrb_ary_aset:
 1029|  15.8k|{
 1030|  15.8k|  mrb_value v1, v2, v3;
 1031|  15.8k|  mrb_int i, len;
 1032|       |
 1033|  15.8k|  if (mrb_get_argc(mrb) == 2) {
  ------------------
  |  Branch (1033:7): [True: 13.0k, False: 2.83k]
  ------------------
 1034|  13.0k|    const mrb_value *vs = mrb_get_argv(mrb);
 1035|  13.0k|    v1 = vs[0]; v2 = vs[1];
 1036|       |
 1037|       |    /* a[n..m] = v */
 1038|  13.0k|    switch (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self), FALSE)) {
  ------------------
  |  |   72|  13.0k|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|  13.0k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  13.0k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  13.0k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 752, False: 12.2k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|    752|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|    752|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  switch (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self), FALSE)) {
  ------------------
  |  |   51|  13.0k|#  define FALSE 0
  ------------------
  |  Branch (1038:13): [True: 0, False: 13.0k]
  ------------------
 1039|  13.0k|    case MRB_RANGE_TYPE_MISMATCH:
  ------------------
  |  Branch (1039:5): [True: 13.0k, False: 0]
  ------------------
 1040|  13.0k|      mrb_ary_set(mrb, self, aget_index(mrb, v1), v2);
 1041|  13.0k|      break;
 1042|      0|    case MRB_RANGE_OK:
  ------------------
  |  Branch (1042:5): [True: 0, False: 13.0k]
  ------------------
 1043|      0|      mrb_ary_splice(mrb, self, i, len, v2);
 1044|      0|      break;
 1045|      0|    case MRB_RANGE_OUT:
  ------------------
  |  Branch (1045:5): [True: 0, False: 13.0k]
  ------------------
 1046|      0|      mrb_raisef(mrb, E_RANGE_ERROR, "%v out of range", v1);
  ------------------
  |  | 1379|      0|#define E_RANGE_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(RangeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1047|      0|      break;
 1048|  13.0k|    }
 1049|  13.0k|    return v2;
 1050|  13.0k|  }
 1051|       |
 1052|  2.83k|  mrb_get_args(mrb, "ooo", &v1, &v2, &v3);
 1053|       |  /* a[n,m] = v */
 1054|  2.83k|  mrb_ary_splice(mrb, self, aget_index(mrb, v1), aget_index(mrb, v2), v3);
 1055|  2.83k|  return v3;
 1056|  15.8k|}
array.c:mrb_ary_index_m:
 1135|  2.17k|{
 1136|  2.17k|  mrb_value obj = mrb_get_arg1(mrb);
 1137|  2.17k|  mrb_int i;
 1138|       |
 1139|  61.1k|  for (i = 0; i < RARRAY_LEN(self); i++) {
  ------------------
  |  |   72|  61.1k|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|  61.1k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  61.1k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  61.1k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 3.14k, False: 58.0k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|  3.14k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  3.14k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1139:15): [True: 60.2k, False: 988]
  ------------------
 1140|  60.2k|    if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) {
  ------------------
  |  |   73|  60.2k|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|  60.2k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  60.2k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  60.2k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 2.16k, False: 58.0k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|  2.16k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1140:9): [True: 1.18k, False: 59.0k]
  ------------------
 1141|  1.18k|      return mrb_int_value(mrb, i);
 1142|  1.18k|    }
 1143|  60.2k|  }
 1144|    988|  return mrb_nil_value();
 1145|  2.17k|}
array.c:mrb_ary_replace_m:
  439|  11.3k|{
  440|  11.3k|  mrb_value other;
  441|       |
  442|  11.3k|  mrb_get_args(mrb, "A", &other);
  443|  11.3k|  mrb_ary_replace(mrb, self, other);
  444|       |
  445|  11.3k|  return self;
  446|  11.3k|}
array.c:mrb_ary_size:
 1191|  62.6k|{
 1192|  62.6k|  struct RArray *a = mrb_ary_ptr(self);
  ------------------
  |  |   51|  62.6k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  62.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1193|       |
 1194|  62.6k|  return mrb_int_value(mrb, ARY_LEN(a));
  ------------------
  |  |   70|  62.6k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  62.6k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  62.6k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 51.2k, False: 11.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  51.2k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  51.2k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1195|  62.6k|}
array.c:mrb_ary_reverse_bang:
  484|  22.6k|{
  485|  22.6k|  struct RArray *a = mrb_ary_ptr(self);
  ------------------
  |  |   51|  22.6k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  22.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  486|  22.6k|  mrb_int len = ARY_LEN(a);
  ------------------
  |  |   70|  22.6k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  22.6k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  22.6k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 22.6k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  22.6k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  22.6k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  487|       |
  488|  22.6k|  if (len > 1) {
  ------------------
  |  Branch (488:7): [True: 0, False: 22.6k]
  ------------------
  489|      0|    mrb_value *p1, *p2;
  490|       |
  491|      0|    ary_modify(mrb, a);
  492|      0|    p1 = ARY_PTR(a);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  493|      0|    p2 = p1 + len - 1;
  494|       |
  495|      0|    while (p1 < p2) {
  ------------------
  |  Branch (495:12): [True: 0, False: 0]
  ------------------
  496|      0|      mrb_value tmp = *p1;
  497|      0|      *p1++ = *p2;
  498|      0|      *p2-- = tmp;
  499|      0|    }
  500|      0|  }
  501|  22.6k|  return self;
  502|  22.6k|}
array.c:mrb_ary_eq:
 1336|  24.8k|{
 1337|  24.8k|  mrb_value ary2 = mrb_get_arg1(mrb);
 1338|       |
 1339|  24.8k|  mrb->c->ci->mid = 0;
 1340|  24.8k|  if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
  ------------------
  |  Branch (1340:7): [True: 0, False: 24.8k]
  ------------------
 1341|  24.8k|  if (!mrb_array_p(ary2)) {
  ------------------
  |  |  186|  24.8k|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|  24.8k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  49.7k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  49.7k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 24.8k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 24.8k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 24.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1342|  24.8k|    return mrb_false_value();
 1343|  24.8k|  }
 1344|      0|  if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
  ------------------
  |  |   72|      0|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
  ------------------
  |  |   72|      0|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1344:7): [True: 0, False: 0]
  ------------------
 1345|       |
 1346|      0|  return ary2;
 1347|      0|}

mrb_keep_backtrace:
  210|    430|{
  211|    430|  int ai;
  212|       |
  213|    430|  if (mrb_exc_ptr(exc)->backtrace) return;
  ------------------
  |  |   32|    430|#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|    430|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  |  Branch (213:7): [True: 0, False: 430]
  ------------------
  214|    430|  ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|    430|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  215|    430|  struct RObject *backtrace = packed_backtrace(mrb);
  216|    430|  store_backtrace(mrb, exc, backtrace);
  217|    430|  mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|    430|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  218|    430|}
backtrace.c:packed_backtrace:
  183|    430|{
  184|    430|  struct RData *backtrace;
  185|    430|  ptrdiff_t ciidx = mrb->c->ci - mrb->c->cibase;
  186|    430|  int len = 0;
  187|    430|  int size;
  188|    430|  void *ptr;
  189|       |
  190|    430|  each_backtrace(mrb, ciidx, count_backtrace_i, &len);
  191|    430|  size = len * sizeof(struct backtrace_location);
  192|    430|  backtrace = mrb_data_object_alloc(mrb, NULL, NULL, &bt_type);
  193|    430|  ptr = mrb_malloc(mrb, size);
  194|    430|  backtrace->data = ptr;
  195|    430|  backtrace->flags = (uint32_t)len;
  196|    430|  each_backtrace(mrb, ciidx, pack_backtrace_i, &ptr);
  197|    430|  return (struct RObject*)backtrace;
  198|    430|}
backtrace.c:each_backtrace:
   34|    860|{
   35|    860|  if (ciidx >= mrb->c->ciend - mrb->c->cibase)
  ------------------
  |  Branch (35:7): [True: 0, False: 860]
  ------------------
   36|      0|    ciidx = 10; /* ciidx is broken... */
   37|       |
   38|  3.46k|  for (ptrdiff_t i=ciidx; i >= 0; i--) {
  ------------------
  |  Branch (38:27): [True: 2.60k, False: 860]
  ------------------
   39|  2.60k|    struct backtrace_location loc;
   40|  2.60k|    mrb_callinfo *ci;
   41|  2.60k|    const mrb_irep *irep = 0;
   42|  2.60k|    const mrb_code *pc;
   43|  2.60k|    uint32_t idx;
   44|       |
   45|  2.60k|    ci = &mrb->c->cibase[i];
   46|       |
   47|  2.60k|    if (!ci->proc || MRB_PROC_CFUNC_P(ci->proc)) {
  ------------------
  |  |   65|  1.85k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|  1.85k|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  |  |  |  Branch (65:29): [True: 0, False: 1.85k]
  |  |  ------------------
  ------------------
  |  Branch (47:9): [True: 744, False: 1.85k]
  ------------------
   48|    744|      if (!ci->mid) continue;
  ------------------
  |  Branch (48:11): [True: 294, False: 450]
  ------------------
   49|    450|      loc.lineno = -1;
   50|    450|      idx = 0;
   51|    450|    }
   52|  1.85k|    else {
   53|  1.85k|      irep = ci->proc->body.irep;
   54|  1.85k|      if (!irep) continue;
  ------------------
  |  Branch (54:11): [True: 0, False: 1.85k]
  ------------------
   55|  1.85k|      if (mrb->c->cibase[i].pc) {
  ------------------
  |  Branch (55:11): [True: 1.85k, False: 0]
  ------------------
   56|  1.85k|        pc = &mrb->c->cibase[i].pc[-1];
   57|  1.85k|      }
   58|      0|      else {
   59|      0|        continue;
   60|      0|      }
   61|  1.85k|      idx = (uint32_t)(pc - irep->iseq);
   62|  1.85k|      mrb_debug_get_position(mrb, irep, idx, &loc.lineno, &loc.filename);
   63|  1.85k|    }
   64|  2.30k|    loc.method_id = ci->mid;
   65|  2.30k|    if (loc.lineno == -1) {
  ------------------
  |  Branch (65:9): [True: 2.30k, False: 0]
  ------------------
   66|  4.35k|      for (ptrdiff_t j=i-1; j >= 0; j--) {
  ------------------
  |  Branch (66:29): [True: 2.04k, False: 2.30k]
  ------------------
   67|  2.04k|        ci = &mrb->c->cibase[j];
   68|       |
   69|  2.04k|        if (!ci->proc) continue;
  ------------------
  |  Branch (69:13): [True: 0, False: 2.04k]
  ------------------
   70|  2.04k|        if (MRB_PROC_CFUNC_P(ci->proc)) continue;
  ------------------
  |  |   65|  2.04k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|  2.04k|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  |  |  |  Branch (65:29): [True: 0, False: 2.04k]
  |  |  ------------------
  ------------------
   71|       |
   72|  2.04k|        irep = ci->proc->body.irep;
   73|  2.04k|        if (!irep) continue;
  ------------------
  |  Branch (73:13): [True: 0, False: 2.04k]
  ------------------
   74|       |
   75|  2.04k|        if (mrb->c->cibase[j].pc) {
  ------------------
  |  Branch (75:13): [True: 2.04k, False: 0]
  ------------------
   76|  2.04k|          pc = &mrb->c->cibase[j].pc[-1];
   77|  2.04k|        }
   78|      0|        else {
   79|      0|          continue;
   80|      0|        }
   81|       |
   82|  2.04k|        idx = (uint32_t)(pc - irep->iseq);
   83|  2.04k|        if (mrb_debug_get_position(mrb, irep, idx, &loc.lineno, &loc.filename)) break;
  ------------------
  |  Branch (83:13): [True: 0, False: 2.04k]
  ------------------
   84|  2.04k|      }
   85|  2.30k|    }
   86|  2.30k|    if (!loc.filename) {
  ------------------
  |  Branch (86:9): [True: 2.30k, False: 0]
  ------------------
   87|  2.30k|      loc.filename = "(unknown)";
   88|  2.30k|    }
   89|       |
   90|  2.30k|    func(mrb, &loc, data);
   91|  2.30k|  }
   92|    860|}
backtrace.c:count_backtrace_i:
  163|  1.15k|{
  164|  1.15k|  int *lenp = (int*)data;
  165|       |
  166|  1.15k|  (*lenp)++;
  167|  1.15k|}
backtrace.c:pack_backtrace_i:
  173|  1.15k|{
  174|  1.15k|  struct backtrace_location **pptr = (struct backtrace_location**)data;
  175|  1.15k|  struct backtrace_location *ptr = *pptr;
  176|       |
  177|  1.15k|  *ptr = *loc;
  178|  1.15k|  *pptr = ptr+1;
  179|  1.15k|}
backtrace.c:store_backtrace:
  202|    430|{
  203|    430|  struct RException *e = mrb_exc_ptr(exc);
  ------------------
  |  |   32|    430|#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|    430|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  204|    430|  e->backtrace = backtrace;
  205|    430|  mrb_field_write_barrier(mrb, (struct RBasic*)e, (struct RBasic*)backtrace);
  206|    430|}

mrb_gc_mark_mt:
  286|  2.79M|{
  287|  2.79M|  mt_tbl *t = c->mt;
  288|       |
  289|  2.79M|  if (t == NULL) return;
  ------------------
  |  Branch (289:7): [True: 739k, False: 2.05M]
  ------------------
  290|  2.05M|  if (t->alloc == 0) return;
  ------------------
  |  Branch (290:7): [True: 483k, False: 1.57M]
  ------------------
  291|  1.57M|  if (t->size == 0) return;
  ------------------
  |  Branch (291:7): [True: 0, False: 1.57M]
  ------------------
  292|       |
  293|  1.57M|  mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
  294|  1.57M|  union mt_ptr *vals = t->ptr;
  295|  36.4M|  for (int i=0; i<t->alloc; i++) {
  ------------------
  |  Branch (295:17): [True: 34.8M, False: 1.57M]
  ------------------
  296|  34.8M|    if (MT_KEY_P(keys[i]) && (keys[i] & MT_FUNC_P) == 0) { /* Proc pointer */
  ------------------
  |  |   27|  69.6M|#define MT_KEY_P(k) (((k)>>2) != 0)
  |  |  ------------------
  |  |  |  Branch (27:21): [True: 21.9M, False: 12.8M]
  |  |  ------------------
  ------------------
                  if (MT_KEY_P(keys[i]) && (keys[i] & MT_FUNC_P) == 0) { /* Proc pointer */
  ------------------
  |  |   28|  21.9M|#define MT_FUNC_P 1
  ------------------
  |  Branch (296:30): [True: 8.93M, False: 13.0M]
  ------------------
  297|  8.93M|      struct RProc *p = vals[i].proc;
  298|  8.93M|      mrb_gc_mark(mrb, (struct RBasic*)p);
  299|  8.93M|    }
  300|  34.8M|  }
  301|  1.57M|  return;
  302|  1.57M|}
mrb_gc_mark_mt_size:
  306|  2.79M|{
  307|  2.79M|  struct mt_tbl *h = c->mt;
  308|       |
  309|  2.79M|  if (!h) return 0;
  ------------------
  |  Branch (309:7): [True: 739k, False: 2.05M]
  ------------------
  310|  2.05M|  return (size_t)h->size;
  311|  2.79M|}
mrb_gc_free_mt:
  315|   303k|{
  316|   303k|  if (c->mt) mt_free(mrb, c->mt);
  ------------------
  |  Branch (316:7): [True: 223k, False: 80.2k]
  ------------------
  317|   303k|}
mrb_class_name_class:
  321|   157k|{
  322|   157k|  mrb_value name;
  323|   157k|  mrb_sym nsym = MRB_SYM(__classname__);
  ------------------
  |  |   18|   157k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  324|       |
  325|   157k|  if (mrb_obj_iv_defined(mrb, (struct RObject*)c, nsym)) return;
  ------------------
  |  Branch (325:7): [True: 13.9k, False: 143k]
  ------------------
  326|   143k|  if (outer == NULL || outer == mrb->object_class) {
  ------------------
  |  Branch (326:7): [True: 3.49k, False: 139k]
  |  Branch (326:24): [True: 123k, False: 15.7k]
  ------------------
  327|   127k|    name = mrb_symbol_value(id);
  328|   127k|  }
  329|  15.7k|  else {
  330|  15.7k|    name = mrb_class_path(mrb, outer);
  331|  15.7k|    if (mrb_nil_p(name)) {      /* unnamed outer class */
  ------------------
  |  |  174|  15.7k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 15.7k]
  |  |  ------------------
  ------------------
  332|      0|      if (outer != mrb->object_class && outer != c) {
  ------------------
  |  Branch (332:11): [True: 0, False: 0]
  |  Branch (332:41): [True: 0, False: 0]
  ------------------
  333|      0|        mrb_obj_iv_set_force(mrb, (struct RObject*)c, MRB_SYM(__outer__),
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  334|      0|                             mrb_obj_value(outer));
  335|      0|      }
  336|      0|      return;
  337|      0|    }
  338|  15.7k|    else {
  339|  15.7k|      mrb_int len;
  340|  15.7k|      const char *n = mrb_sym_name_len(mrb, id, &len);
  341|       |
  342|  15.7k|      mrb_str_cat_lit(mrb, name, "::");
  ------------------
  |  |  395|  15.7k|#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  15.7k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  343|  15.7k|      mrb_str_cat(mrb, name, n, len);
  344|  15.7k|    }
  345|  15.7k|  }
  346|   143k|  mrb_obj_iv_set_force(mrb, (struct RObject*)c, nsym, name);
  347|   143k|}
mrb_const_name_p:
  351|  1.74k|{
  352|  1.74k|  return len > 0 && ISUPPER(name[0]) && mrb_ident_p(name+1, len-1);
  ------------------
  |  | 1339|  3.49k|#define ISUPPER(c) (((unsigned)(c) - 'A') < 26)
  |  |  ------------------
  |  |  |  Branch (1339:20): [True: 1.74k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (352:10): [True: 1.74k, False: 0]
  |  Branch (352:41): [True: 1.74k, False: 0]
  ------------------
  353|  1.74k|}
mrb_define_module_id:
  469|  1.74k|{
  470|  1.74k|  return define_module(mrb, name, mrb->object_class);
  471|  1.74k|}
mrb_define_module:
  475|  12.2k|{
  476|  12.2k|  return define_module(mrb, mrb_intern_cstr(mrb, name), mrb->object_class);
  477|  12.2k|}
mrb_vm_define_module:
  481|  26.1k|{
  482|  26.1k|  check_if_class_or_module(mrb, outer);
  483|  26.1k|  if (mrb_const_defined_at(mrb, outer, id)) {
  ------------------
  |  Branch (483:7): [True: 26.1k, False: 0]
  ------------------
  484|  26.1k|    mrb_value old = mrb_const_get(mrb, outer, id);
  485|       |
  486|  26.1k|    if (!mrb_module_p(old)) {
  ------------------
  |  |  194|  26.1k|#define mrb_module_p(o) WORDBOX_OBJ_TYPE_P(o, MODULE)
  |  |  ------------------
  |  |  |  |   78|  26.1k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  52.3k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  52.3k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 26.1k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 26.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 26.1k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  487|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a module", old);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  488|      0|    }
  489|  26.1k|    return mrb_class_ptr(old);
  ------------------
  |  |   24|  26.1k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  26.1k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  490|  26.1k|  }
  491|      0|  return define_module(mrb, id, mrb_class_ptr(outer));
  ------------------
  |  |   24|      0|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  492|  26.1k|}
mrb_define_module_under_id:
  496|  1.74k|{
  497|  1.74k|  struct RClass * c = define_module(mrb, name, outer);
  498|       |
  499|  1.74k|  setup_class(mrb, outer, c, name);
  500|  1.74k|  return c;
  501|  1.74k|}
mrb_define_module_under:
  505|  1.74k|{
  506|  1.74k|  mrb_sym id = mrb_intern_cstr(mrb, name);
  507|  1.74k|  struct RClass * c = define_module(mrb, id, outer);
  508|       |
  509|  1.74k|  setup_class(mrb, outer, c, id);
  510|  1.74k|  return c;
  511|  1.74k|}
mrb_define_class_id:
  543|  76.7k|{
  544|  76.7k|  if (!super) {
  ------------------
  |  Branch (544:7): [True: 0, False: 76.7k]
  ------------------
  545|      0|    mrb_warn(mrb, "no super class for '%n', Object assumed", name);
  546|      0|  }
  547|  76.7k|  return define_class(mrb, name, super, mrb->object_class);
  548|  76.7k|}
mrb_define_class:
  552|  69.8k|{
  553|  69.8k|  return mrb_define_class_id(mrb, mrb_intern_cstr(mrb, name), super);
  554|  69.8k|}
mrb_vm_define_class:
  584|   116k|{
  585|   116k|  struct RClass *s;
  586|   116k|  struct RClass *c;
  587|       |
  588|   116k|  if (!mrb_nil_p(super)) {
  ------------------
  |  |  174|   116k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
  |  Branch (588:7): [True: 50.6k, False: 66.3k]
  ------------------
  589|  50.6k|    if (!mrb_class_p(super)) {
  ------------------
  |  |  193|  50.6k|#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS)
  |  |  ------------------
  |  |  |  |   78|  50.6k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|   101k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|   101k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 50.6k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 50.6k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 50.6k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  590|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%!v given)", super);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  591|      0|    }
  592|  50.6k|    s = mrb_class_ptr(super);
  ------------------
  |  |   24|  50.6k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  50.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  593|  50.6k|  }
  594|  66.3k|  else {
  595|  66.3k|    s = NULL;
  596|  66.3k|  }
  597|   116k|  check_if_class_or_module(mrb, outer);
  598|   116k|  if (mrb_const_defined_at(mrb, outer, id)) {
  ------------------
  |  Branch (598:7): [True: 75.0k, False: 41.8k]
  ------------------
  599|  75.0k|    mrb_value old = mrb_const_get(mrb, outer, id);
  600|       |
  601|  75.0k|    if (!mrb_class_p(old)) {
  ------------------
  |  |  193|  75.0k|#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS)
  |  |  ------------------
  |  |  |  |   78|  75.0k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|   150k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|   150k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 75.0k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 75.0k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 75.0k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  602|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a class", old);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  603|      0|    }
  604|  75.0k|    c = mrb_class_ptr(old);
  ------------------
  |  |   24|  75.0k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  75.0k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  605|  75.0k|    if (s) {
  ------------------
  |  Branch (605:9): [True: 17.4k, False: 57.5k]
  ------------------
  606|       |      /* check super class */
  607|  17.4k|      if (mrb_class_real(c->super) != s) {
  ------------------
  |  Branch (607:11): [True: 0, False: 17.4k]
  ------------------
  608|      0|        mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for class %v", old);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  609|      0|      }
  610|  17.4k|    }
  611|  75.0k|    return c;
  612|  75.0k|  }
  613|  41.8k|  c = define_class(mrb, id, s, mrb_class_ptr(outer));
  ------------------
  |  |   24|  41.8k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  41.8k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  614|  41.8k|  mrb_class_inherited(mrb, mrb_class_real(c->super), c);
  615|       |
  616|  41.8k|  return c;
  617|   116k|}
mrb_class_get_under_id:
  655|  17.4k|{
  656|  17.4k|  return class_from_sym(mrb, outer, name);
  657|  17.4k|}
mrb_class_get_id:
  667|  17.4k|{
  668|  17.4k|  return mrb_class_get_under_id(mrb, mrb->object_class, name);
  669|  17.4k|}
mrb_exc_get_id:
  673|  2.35k|{
  674|  2.35k|  struct RClass *exc, *e;
  675|  2.35k|  mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), name);
  676|       |
  677|  2.35k|  if (!mrb_class_p(c)) {
  ------------------
  |  |  193|  2.35k|#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS)
  |  |  ------------------
  |  |  |  |   78|  2.35k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  4.71k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  4.71k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 2.35k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 2.35k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 2.35k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  678|      0|    mrb_raise(mrb, E_EXCEPTION, "exception corrupted");
  ------------------
  |  | 1372|      0|#define E_EXCEPTION          mrb->eException_class
  ------------------
  679|      0|  }
  680|  2.35k|  exc = e = mrb_class_ptr(c);
  ------------------
  |  |   24|  2.35k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  2.35k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  681|       |
  682|  7.00k|  while (e) {
  ------------------
  |  Branch (682:10): [True: 7.00k, False: 0]
  ------------------
  683|  7.00k|    if (e == E_EXCEPTION)
  ------------------
  |  | 1372|  7.00k|#define E_EXCEPTION          mrb->eException_class
  ------------------
  |  Branch (683:9): [True: 2.35k, False: 4.65k]
  ------------------
  684|  2.35k|      return exc;
  685|  4.65k|    e = e->super;
  686|  4.65k|  }
  687|      0|  return E_EXCEPTION;
  ------------------
  |  | 1372|      0|#define E_EXCEPTION          mrb->eException_class
  ------------------
  688|  2.35k|}
mrb_module_get_under:
  692|  5.23k|{
  693|  5.23k|  return module_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
  694|  5.23k|}
mrb_module_get_under_id:
  698|  1.74k|{
  699|  1.74k|  return module_from_sym(mrb, outer, name);
  700|  1.74k|}
mrb_module_get:
  704|  5.23k|{
  705|  5.23k|  return mrb_module_get_under(mrb, mrb->object_class, name);
  706|  5.23k|}
mrb_module_get_id:
  710|  1.74k|{
  711|  1.74k|  return mrb_module_get_under_id(mrb, mrb->object_class, name);
  712|  1.74k|}
mrb_define_class_under_id:
  732|  5.23k|{
  733|  5.23k|  struct RClass * c;
  734|       |
  735|       |#if 0
  736|       |  if (!super) {
  737|       |    mrb_warn(mrb, "no super class for '%C::%n', Object assumed", outer, id);
  738|       |  }
  739|       |#endif
  740|  5.23k|  c = define_class(mrb, name, super, outer);
  741|  5.23k|  setup_class(mrb, outer, c, name);
  742|  5.23k|  return c;
  743|  5.23k|}
mrb_define_method_raw:
  753|  2.41M|{
  754|  2.41M|  mt_tbl *h;
  755|  2.41M|  union mt_ptr ptr;
  756|       |
  757|  2.41M|  MRB_CLASS_ORIGIN(c);
  ------------------
  |  |   65|  2.41M|#define MRB_CLASS_ORIGIN(c) do {\
  |  |   66|  2.41M|  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
  |  |  ------------------
  |  |  |  |   63|  2.41M|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  |  |  ------------------
  |  |  |  Branch (66:7): [True: 0, False: 2.41M]
  |  |  ------------------
  |  |   67|      0|    (c) = (c)->super;\
  |  |   68|      0|    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
  |  |  ------------------
  |  |  |  Branch (68:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|      (c) = (c)->super;\
  |  |   70|      0|    }\
  |  |   71|      0|  }\
  |  |   72|  2.41M|} while (0)
  |  |  ------------------
  |  |  |  Branch (72:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  758|  2.41M|  h = c->mt;
  759|  2.41M|  if (c->tt == MRB_TT_SCLASS && mrb_frozen_p(c)) {
  ------------------
  |  |   28|   382k|#define mrb_frozen_p(o) MRB_FROZEN_P(o)
  |  |  ------------------
  |  |  |  |   25|   382k|#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
  |  |  |  |  ------------------
  |  |  |  |  |  |   24|   382k|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (25:25): [True: 0, False: 382k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (759:7): [True: 382k, False: 2.02M]
  ------------------
  760|      0|    mrb_value v = mrb_iv_get(mrb, mrb_obj_value(c), MRB_SYM(__attached__));
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  761|      0|    mrb_check_frozen_value(mrb, v);
  762|      0|  }
  763|  2.41M|  else {
  764|  2.41M|    mrb_check_frozen(mrb, c);
  765|  2.41M|  }
  766|  2.41M|  if (!h) h = c->mt = mt_new(mrb);
  ------------------
  |  Branch (766:7): [True: 76.7k, False: 2.33M]
  ------------------
  767|  2.41M|  if (MRB_METHOD_PROC_P(m)) {
  ------------------
  |  |  113|  2.41M|#define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
  |  |  ------------------
  |  |  |  |  107|  2.41M|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|  2.41M|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (113:30): [True: 983k, False: 1.42M]
  |  |  ------------------
  ------------------
  768|   983k|    struct RProc *p = MRB_METHOD_PROC(m);
  ------------------
  |  |  114|   983k|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  ------------------
  769|       |
  770|   983k|    ptr.proc = p;
  771|   983k|    if (p) {
  ------------------
  |  Branch (771:9): [True: 952k, False: 31.4k]
  ------------------
  772|   952k|      if (p->color != MRB_GC_RED) {
  ------------------
  |  |   90|   952k|#define MRB_GC_RED 7
  ------------------
  |  Branch (772:11): [True: 947k, False: 5.23k]
  ------------------
  773|   947k|        p->flags |= MRB_PROC_SCOPE;
  ------------------
  |  |   85|   947k|#define MRB_PROC_SCOPE 2048
  ------------------
  774|   947k|        p->c = NULL;
  775|   947k|        mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p);
  776|   947k|        if (!MRB_PROC_ENV_P(p)) {
  ------------------
  |  |   72|   947k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|   947k|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  ------------------
  |  Branch (776:13): [True: 809k, False: 137k]
  ------------------
  777|   809k|          MRB_PROC_SET_TARGET_CLASS(p, c);
  ------------------
  |  |   75|   809k|#define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
  |  |   76|   809k|  if (MRB_PROC_ENV_P(p)) {\
  |  |  ------------------
  |  |  |  |   72|   809k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   809k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 809k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|    (p)->e.env->c = (tc);\
  |  |   78|      0|    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)(tc));\
  |  |   79|      0|  }\
  |  |   80|   809k|  else {\
  |  |   81|   809k|    (p)->e.target_class = (tc);\
  |  |   82|   809k|    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)(tc));\
  |  |   83|   809k|  }\
  |  |   84|   809k|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  778|   809k|        }
  779|   947k|      }
  780|  5.23k|      else {
  781|  5.23k|        mrb_assert(MRB_FROZEN_P(p) && MRB_PROC_SCOPE_P(p));
  ------------------
  |  |   68|  5.23k|#define mrb_assert(p) ((void)0)
  ------------------
  782|  5.23k|        mrb_assert(p->c == NULL && p->upper == NULL && p->e.target_class == NULL);
  ------------------
  |  |   68|  5.23k|#define mrb_assert(p) ((void)0)
  ------------------
  783|  5.23k|      }
  784|   952k|    }
  785|   983k|  }
  786|  1.42M|  else {
  787|  1.42M|    ptr.func = MRB_METHOD_FUNC(m);
  ------------------
  |  |  110|  1.42M|#define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)>>2))
  ------------------
  788|  1.42M|  }
  789|  2.41M|  mt_put(mrb, h, mid, MT_FLAGS(MRB_METHOD_FUNC_P(m), MRB_METHOD_NOARG_P(m)), ptr);
  ------------------
  |  |   34|  4.82M|#define MT_FLAGS(func_p, noarg_p) ((func_p)?MT_FUNC_P:0)|((noarg_p)?MT_NOARG_P:0)
  |  |  ------------------
  |  |  |  |   28|  1.42M|#define MT_FUNC_P 1
  |  |  ------------------
  |  |               #define MT_FLAGS(func_p, noarg_p) ((func_p)?MT_FUNC_P:0)|((noarg_p)?MT_NOARG_P:0)
  |  |  ------------------
  |  |  |  |   29|   497k|#define MT_NOARG_P 2
  |  |  ------------------
  |  |  |  Branch (34:36): [True: 1.42M, False: 983k]
  |  |  |  Branch (34:59): [True: 497k, False: 1.91M]
  |  |  |  Branch (34:60): [True: 497k, False: 1.91M]
  |  |  ------------------
  ------------------
  790|  2.41M|  mc_clear_by_id(mrb, mid);
  791|  2.41M|}
mrb_define_method_id:
  795|  1.39M|{
  796|  1.39M|  mrb_method_t m;
  797|  1.39M|  int ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  1.39M|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  798|       |
  799|  1.39M|  MRB_METHOD_FROM_FUNC(m, func);
  ------------------
  |  |  111|  1.39M|#define MRB_METHOD_FROM_FUNC(m,fn) ((m)=(mrb_method_t)((((uintptr_t)(fn))<<2)|MRB_METHOD_FUNC_FL))
  |  |  ------------------
  |  |  |  |  102|  1.39M|#define MRB_METHOD_FUNC_FL 1
  |  |  ------------------
  ------------------
  800|  1.39M|#ifndef MRB_USE_METHOD_T_STRUCT
  801|  1.39M|  mrb_assert(MRB_METHOD_FUNC(m) == func);
  ------------------
  |  |   68|  1.39M|#define mrb_assert(p) ((void)0)
  ------------------
  802|  1.39M|#endif
  803|  1.39M|  if (aspec == MRB_ARGS_NONE()) {
  ------------------
  |  |  919|  1.39M|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  |  Branch (803:7): [True: 483k, False: 910k]
  ------------------
  804|   483k|    MRB_METHOD_NOARG_SET(m);
  ------------------
  |  |  109|   483k|#define MRB_METHOD_NOARG_SET(m) ((m)=(mrb_method_t)(((uintptr_t)(m))|MRB_METHOD_NOARG_FL))
  |  |  ------------------
  |  |  |  |  103|   483k|#define MRB_METHOD_NOARG_FL 2
  |  |  ------------------
  ------------------
  805|   483k|  }
  806|  1.39M|  mrb_define_method_raw(mrb, c, mid, m);
  807|  1.39M|  mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  1.39M|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  808|  1.39M|}
mrb_define_method:
  812|  1.04M|{
  813|  1.04M|  mrb_define_method_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
  814|  1.04M|}
mrb_get_argc:
  848|  47.9k|{
  849|  47.9k|  mrb_int argc = mrb->c->ci->n;
  850|       |
  851|  47.9k|  if (argc == 15) {
  ------------------
  |  Branch (851:7): [True: 0, False: 47.9k]
  ------------------
  852|      0|    struct RArray *a = mrb_ary_ptr(mrb->c->ci->stack[1]);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  853|       |
  854|      0|    argc = ARY_LEN(a);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  855|      0|  }
  856|  47.9k|  return argc;
  857|  47.9k|}
mrb_get_argv:
  861|  42.8k|{
  862|  42.8k|  mrb_int argc = mrb->c->ci->n;
  863|  42.8k|  mrb_value *array_argv = mrb->c->ci->stack + 1;
  864|  42.8k|  if (argc == 15) {
  ------------------
  |  Branch (864:7): [True: 0, False: 42.8k]
  ------------------
  865|      0|    struct RArray *a = mrb_ary_ptr(*array_argv);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  866|       |
  867|      0|    array_argv = ARY_PTR(a);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  868|      0|  }
  869|  42.8k|  return array_argv;
  870|  42.8k|}
mrb_get_arg1:
  874|   140k|{
  875|   140k|  mrb_callinfo *ci = mrb->c->ci;
  876|   140k|  mrb_int argc = ci->n;
  877|   140k|  mrb_value *array_argv = ci->stack + 1;
  878|   140k|  if (argc == 15) {
  ------------------
  |  Branch (878:7): [True: 0, False: 140k]
  ------------------
  879|      0|    struct RArray *a = mrb_ary_ptr(*array_argv);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  880|       |
  881|      0|    argc = ARY_LEN(a);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  882|      0|    array_argv = ARY_PTR(a);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  883|      0|  }
  884|   140k|  if (argc == 0 && ci->nk == 15) {
  ------------------
  |  Branch (884:7): [True: 0, False: 140k]
  |  Branch (884:20): [True: 0, False: 0]
  ------------------
  885|      0|    mrb_int n = ci->n;
  886|      0|    if (n == 15) n = 1;
  ------------------
  |  Branch (886:9): [True: 0, False: 0]
  ------------------
  887|      0|    return ci->stack[n+1];      /* kwhash next to positional arguments */
  888|      0|  }
  889|   140k|  if (argc != 1) {
  ------------------
  |  Branch (889:7): [True: 0, False: 140k]
  ------------------
  890|      0|    mrb_argnum_error(mrb, argc, 1, 1);
  891|      0|  }
  892|   140k|  return array_argv[0];
  893|   140k|}
mrb_block_given_p:
  897|  5.23k|{
  898|  5.23k|  mrb_callinfo *ci = mrb->c->ci;
  899|  5.23k|  mrb_value b = ci->stack[mrb_ci_bidx(ci)];
  900|       |
  901|  5.23k|  return !mrb_nil_p(b);
  ------------------
  |  |  174|  5.23k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
  902|  5.23k|}
mrb_get_args:
 1358|   161k|{
 1359|   161k|  va_list ap;
 1360|   161k|  va_start(ap, format);
 1361|   161k|  mrb_int rc = get_args_v(mrb, format, NULL, &ap);
 1362|   161k|  va_end(ap);
 1363|   161k|  return rc;
 1364|   161k|}
mrb_include_module:
 1479|  29.6k|{
 1480|  29.6k|  mrb_check_frozen(mrb, c);
 1481|  29.6k|  if (include_module_at(mrb, c, find_origin(c), m, 1) < 0) {
  ------------------
  |  Branch (1481:7): [True: 0, False: 29.6k]
  ------------------
 1482|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "cyclic include detected");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1483|      0|  }
 1484|  29.6k|  if (c->tt == MRB_TT_MODULE && (c->flags & MRB_FL_CLASS_IS_INHERITED)) {
  ------------------
  |  |   73|  1.74k|#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
  ------------------
  |  Branch (1484:7): [True: 1.74k, False: 27.9k]
  |  Branch (1484:33): [True: 0, False: 1.74k]
  ------------------
 1485|      0|    struct RClass *data[2];
 1486|      0|    data[0] = c;
 1487|      0|    data[1] = m;
 1488|      0|    mrb_objspace_each_objects(mrb, fix_include_module, data);
 1489|      0|  }
 1490|  29.6k|}
mrb_singleton_class_ptr:
 1656|   113k|{
 1657|   113k|  struct RBasic *obj;
 1658|       |
 1659|   113k|  switch (mrb_type(v)) {
 1660|      0|  case MRB_TT_FALSE:
  ------------------
  |  Branch (1660:3): [True: 0, False: 113k]
  ------------------
 1661|      0|    if (mrb_nil_p(v))
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1662|      0|      return mrb->nil_class;
 1663|      0|    return mrb->false_class;
 1664|      0|  case MRB_TT_TRUE:
  ------------------
  |  Branch (1664:3): [True: 0, False: 113k]
  ------------------
 1665|      0|    return mrb->true_class;
 1666|      0|  case MRB_TT_CPTR:
  ------------------
  |  Branch (1666:3): [True: 0, False: 113k]
  ------------------
 1667|      0|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (1667:3): [True: 0, False: 113k]
  ------------------
 1668|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (1668:3): [True: 0, False: 113k]
  ------------------
 1669|      0|#ifndef MRB_NO_FLOAT
 1670|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (1670:3): [True: 0, False: 113k]
  ------------------
 1671|      0|#endif
 1672|      0|    return NULL;
 1673|   113k|  default:
  ------------------
  |  Branch (1673:3): [True: 113k, False: 0]
  ------------------
 1674|   113k|    break;
 1675|   113k|  }
 1676|   113k|  obj = mrb_basic_ptr(v);
  ------------------
  |  |   22|   113k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   113k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1677|   113k|  if (obj->c == NULL) return NULL;
  ------------------
  |  Branch (1677:7): [True: 0, False: 113k]
  ------------------
 1678|   113k|  prepare_singleton_class(mrb, obj);
 1679|   113k|  return obj->c;
 1680|   113k|}
mrb_singleton_class:
 1684|   113k|{
 1685|   113k|  struct RClass *c = mrb_singleton_class_ptr(mrb, v);
 1686|       |
 1687|   113k|  if (c == NULL) {
  ------------------
  |  Branch (1687:7): [True: 0, False: 113k]
  ------------------
 1688|      0|    mrb_raise(mrb, E_TYPE_ERROR, "can't define singleton");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1689|      0|  }
 1690|   113k|  return mrb_obj_value(c);
 1691|   113k|}
mrb_define_singleton_method:
 1695|   160k|{
 1696|   160k|  prepare_singleton_class(mrb, (struct RBasic*)o);
 1697|   160k|  mrb_define_method_id(mrb, o->c, mrb_intern_cstr(mrb, name), func, aspec);
 1698|   160k|}
mrb_define_singleton_method_id:
 1702|  90.7k|{
 1703|  90.7k|  prepare_singleton_class(mrb, (struct RBasic*)o);
 1704|  90.7k|  mrb_define_method_id(mrb, o->c, name, func, aspec);
 1705|  90.7k|}
mrb_define_class_method:
 1709|   155k|{
 1710|   155k|  mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec);
 1711|   155k|}
mrb_define_class_method_id:
 1715|  90.7k|{
 1716|  90.7k|  mrb_define_singleton_method_id(mrb, (struct RObject*)c, name, func, aspec);
 1717|  90.7k|}
mrb_define_module_function_id:
 1721|  90.7k|{
 1722|  90.7k|  mrb_define_class_method_id(mrb, c, name, func, aspec);
 1723|  90.7k|  mrb_define_method_id(mrb, c, name, func, aspec);
 1724|  90.7k|}
mrb_define_module_function:
 1728|  90.7k|{
 1729|  90.7k|  mrb_define_module_function_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
 1730|  90.7k|}
mrb_vm_find_method:
 1768|  1.88M|{
 1769|  1.88M|  mrb_method_t m;
 1770|  1.88M|#ifndef MRB_NO_METHOD_CACHE
 1771|  1.88M|  struct RClass *oc = c;
 1772|  1.88M|  int h = kh_int_hash_func(mrb, ((intptr_t)oc) ^ mid) & (MRB_METHOD_CACHE_SIZE-1);
  ------------------
  |  |  267|  1.88M|#define kh_int_hash_func(mrb,key) (khint_t)((key)^((key)<<2)^((key)>>2))
  ------------------
                int h = kh_int_hash_func(mrb, ((intptr_t)oc) ^ mid) & (MRB_METHOD_CACHE_SIZE-1);
  ------------------
  |  |  218|  1.88M|# define MRB_METHOD_CACHE_SIZE (1<<8)
  ------------------
 1773|  1.88M|  struct mrb_cache_entry *mc = &mrb->cache[h];
 1774|       |
 1775|  1.88M|  if (mc->c == c && mc->mid == mid) {
  ------------------
  |  Branch (1775:7): [True: 1.36M, False: 517k]
  |  Branch (1775:21): [True: 1.36M, False: 8.09k]
  ------------------
 1776|  1.36M|    *cp = mc->c0;
 1777|  1.36M|    return mc->m;
 1778|  1.36M|  }
 1779|   525k|#endif
 1780|       |
 1781|  1.59M|  while (c) {
  ------------------
  |  Branch (1781:10): [True: 1.59M, False: 126]
  ------------------
 1782|  1.59M|    mt_tbl *h = c->mt;
 1783|       |
 1784|  1.59M|    if (h) {
  ------------------
  |  Branch (1784:9): [True: 1.05M, False: 539k]
  ------------------
 1785|  1.05M|      union mt_ptr ptr;
 1786|  1.05M|      mrb_sym ret = mt_get(mrb, h, mid, &ptr);
 1787|  1.05M|      if (ret) {
  ------------------
  |  Branch (1787:11): [True: 525k, False: 530k]
  ------------------
 1788|   525k|        if (ptr.proc == 0) break;
  ------------------
  |  Branch (1788:13): [True: 0, False: 525k]
  ------------------
 1789|   525k|        *cp = c;
 1790|   525k|        m =  create_method_value(mrb, ret, ptr);
 1791|   525k|#ifndef MRB_NO_METHOD_CACHE
 1792|   525k|        mc->c = oc;
 1793|   525k|        mc->c0 = c;
 1794|   525k|        mc->mid = mid;
 1795|   525k|        mc->m = m;
 1796|   525k|#endif
 1797|   525k|        return m;
 1798|   525k|      }
 1799|  1.05M|    }
 1800|  1.06M|    c = c->super;
 1801|  1.06M|  }
 1802|    126|  MRB_METHOD_FROM_PROC(m, NULL);
  ------------------
  |  |  112|    126|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
 1803|    126|  return m;                  /* no method */
 1804|   525k|}
mrb_method_search_vm:
 1808|  1.10M|{
 1809|  1.10M|  return mrb_vm_find_method(mrb, *cp, cp, mid);
 1810|  1.10M|}
mrb_method_search:
 1814|   127k|{
 1815|   127k|  mrb_method_t m;
 1816|       |
 1817|   127k|  m = mrb_method_search_vm(mrb, &c, mid);
 1818|   127k|  if (MRB_METHOD_UNDEF_P(m)) {
  ------------------
  |  |  115|   127k|#define MRB_METHOD_UNDEF_P(m) ((m)==0)
  |  |  ------------------
  |  |  |  Branch (115:31): [True: 0, False: 127k]
  |  |  ------------------
  ------------------
 1819|      0|    mrb_name_error(mrb, mid, "undefined method '%n' for class %C", mid, c);
 1820|      0|  }
 1821|   127k|  return m;
 1822|   127k|}
mrb_obj_new:
 1984|  1.74k|{
 1985|  1.74k|  mrb_value obj;
 1986|  1.74k|  mrb_sym mid;
 1987|       |
 1988|  1.74k|  obj = mrb_instance_alloc(mrb, mrb_obj_value(c));
 1989|  1.74k|  mid = MRB_SYM(initialize);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 1990|  1.74k|  if (!mrb_func_basic_p(mrb, obj, mid, mrb_do_nothing)) {
  ------------------
  |  Branch (1990:7): [True: 1.74k, False: 0]
  ------------------
 1991|  1.74k|    mrb_funcall_argv(mrb, obj, mid, argc, argv);
 1992|  1.74k|  }
 1993|  1.74k|  return obj;
 1994|  1.74k|}
mrb_obj_equal_m:
 2095|  1.46k|{
 2096|  1.46k|  mrb_value arg = mrb_get_arg1(mrb);
 2097|       |
 2098|  1.46k|  return mrb_bool_value(mrb_obj_equal(mrb, self, arg));
 2099|  1.46k|}
mrb_obj_respond_to:
 2103|  1.75k|{
 2104|  1.75k|  mrb_method_t m;
 2105|       |
 2106|  1.75k|  m = mrb_method_search_vm(mrb, &c, mid);
 2107|  1.75k|  if (MRB_METHOD_UNDEF_P(m)) {
  ------------------
  |  |  115|  1.75k|#define MRB_METHOD_UNDEF_P(m) ((m)==0)
  |  |  ------------------
  |  |  |  Branch (115:31): [True: 0, False: 1.75k]
  |  |  ------------------
  ------------------
 2108|      0|    return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2109|      0|  }
 2110|  1.75k|  return TRUE;
  ------------------
  |  |   54|  1.75k|#  define TRUE 1
  ------------------
 2111|  1.75k|}
mrb_respond_to:
 2115|      5|{
 2116|      5|  return mrb_obj_respond_to(mrb, mrb_class(mrb, obj), mid);
 2117|      5|}
mrb_class_path:
 2121|  15.7k|{
 2122|  15.7k|  mrb_value path;
 2123|  15.7k|  mrb_sym nsym = MRB_SYM(__classname__);
  ------------------
  |  |   18|  15.7k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2124|       |
 2125|  15.7k|  path = mrb_obj_iv_get(mrb, (struct RObject*)c, nsym);
 2126|  15.7k|  if (mrb_nil_p(path)) {
  ------------------
  |  |  174|  15.7k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 15.7k]
  |  |  ------------------
  ------------------
 2127|       |    /* no name (yet) */
 2128|      0|    return mrb_class_find_path(mrb, c);
 2129|      0|  }
 2130|  15.7k|  else if (mrb_symbol_p(path)) {
  ------------------
  |  |  172|  15.7k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  15.7k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 15.7k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2131|       |    /* toplevel class/module */
 2132|  15.7k|    return mrb_sym_str(mrb, mrb_symbol(path));
  ------------------
  |  |  167|  15.7k|#define mrb_symbol(o)  (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT)
  |  |  ------------------
  |  |  |  |   63|  15.7k|#define WORDBOX_SYMBOL_SHIFT    32
  |  |  ------------------
  ------------------
 2133|  15.7k|  }
 2134|      0|  return mrb_str_dup(mrb, path);
 2135|  15.7k|}
mrb_class_real:
 2139|  61.0k|{
 2140|  61.0k|  if (cl == 0) return NULL;
  ------------------
  |  Branch (2140:7): [True: 0, False: 61.0k]
  ------------------
 2141|  61.0k|  while ((cl->tt == MRB_TT_SCLASS) || (cl->tt == MRB_TT_ICLASS)) {
  ------------------
  |  Branch (2141:10): [True: 0, False: 61.0k]
  |  Branch (2141:39): [True: 0, False: 61.0k]
  ------------------
 2142|      0|    cl = cl->super;
 2143|      0|    if (cl == 0) return NULL;
  ------------------
  |  Branch (2143:9): [True: 0, False: 0]
  ------------------
 2144|      0|  }
 2145|  61.0k|  return cl;
 2146|  61.0k|}
mrb_class_new:
 2192|   122k|{
 2193|   122k|  struct RClass *c;
 2194|       |
 2195|   122k|  if (super) {
  ------------------
  |  Branch (2195:7): [True: 113k, False: 8.72k]
  ------------------
 2196|   113k|    mrb_check_inheritable(mrb, super);
 2197|   113k|  }
 2198|   122k|  c = boot_defclass(mrb, super);
 2199|   122k|  if (super) {
  ------------------
  |  Branch (2199:7): [True: 113k, False: 8.72k]
  ------------------
 2200|   113k|    MRB_SET_INSTANCE_TT(c, MRB_INSTANCE_TT(super));
  ------------------
  |  |   75|   113k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|   113k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 2201|   113k|  }
 2202|   122k|  make_metaclass(mrb, c);
  ------------------
  |  |  362|   122k|#define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  ------------------
 2203|       |
 2204|   122k|  return c;
 2205|   122k|}
mrb_module_new:
 2212|  17.4k|{
 2213|  17.4k|  struct RClass *m = MRB_OBJ_ALLOC(mrb, MRB_TT_MODULE, mrb->module_class);
  ------------------
  |  | 1200|  17.4k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 2214|  17.4k|  boot_initmod(mrb, m);
 2215|  17.4k|  return m;
 2216|  17.4k|}
mrb_alias_method:
 2240|   127k|{
 2241|   127k|  if (a == b) return;
  ------------------
  |  Branch (2241:7): [True: 0, False: 127k]
  ------------------
 2242|   127k|  mrb_method_t m = mrb_method_search(mrb, c, b);
 2243|       |
 2244|   127k|  if (!MRB_METHOD_CFUNC_P(m)) {
  ------------------
  |  |  131|   127k|#define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |  107|   127k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|   127k|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (107:30): [True: 33.1k, False: 94.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   54|  33.1k|#  define TRUE 1
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |  114|  94.2k|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (114:28): [True: 94.2k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   65|  94.2k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  94.2k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  ------------------
  ------------------
  |  Branch (2244:7): [True: 94.2k, False: 33.1k]
  ------------------
 2245|  94.2k|    struct RProc *p = MRB_METHOD_PROC(m);
  ------------------
  |  |  114|  94.2k|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  ------------------
 2246|       |
 2247|  94.2k|    if (MRB_PROC_ENV_P(p)) {
  ------------------
  |  |   72|  94.2k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|  94.2k|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 8.72k, False: 85.5k]
  |  |  ------------------
  ------------------
 2248|  8.72k|      MRB_PROC_ENV(p)->mid = b;
  ------------------
  |  |   73|  8.72k|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|  8.72k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  8.72k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 8.72k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2249|  8.72k|    }
 2250|  85.5k|    else if (p->color != MRB_GC_RED) {
  ------------------
  |  |   90|  85.5k|#define MRB_GC_RED 7
  ------------------
  |  Branch (2250:14): [True: 85.5k, False: 0]
  ------------------
 2251|  85.5k|      struct RClass *tc = MRB_PROC_TARGET_CLASS(p);
  ------------------
  |  |   74|  85.5k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|  85.5k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  85.5k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 85.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2252|  85.5k|      struct REnv *e = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL);
  ------------------
  |  | 1200|  85.5k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 2253|       |
 2254|  85.5k|      e->mid = b;
 2255|  85.5k|      if (tc) {
  ------------------
  |  Branch (2255:11): [True: 85.5k, False: 0]
  ------------------
 2256|  85.5k|        e->c = tc;
 2257|  85.5k|        mrb_field_write_barrier(mrb, (struct RBasic*)e, (struct RBasic*)tc);
 2258|  85.5k|      }
 2259|  85.5k|      p->e.env = e;
 2260|  85.5k|      p->flags |= MRB_PROC_ENVSET;
  ------------------
  |  |   71|  85.5k|#define MRB_PROC_ENVSET 1024
  ------------------
 2261|  85.5k|      mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
 2262|  85.5k|    }
 2263|  94.2k|  }
 2264|   127k|  mrb_define_method_raw(mrb, c, a, m);
 2265|   127k|}
mrb_define_alias:
 2276|  3.49k|{
 2277|  3.49k|  mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2));
 2278|  3.49k|}
mrb_mod_to_s:
 2297|     92|{
 2298|     92|  if (mrb_sclass_p(klass)) {
  ------------------
  |  |  196|     92|#define mrb_sclass_p(o) WORDBOX_OBJ_TYPE_P(o, SCLASS)
  |  |  ------------------
  |  |  |  |   78|     92|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|    184|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|    184|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 92]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 92]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 92]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2299|      0|    mrb_value v = mrb_iv_get(mrb, klass, MRB_SYM(__attached__));
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2300|      0|    mrb_value str = mrb_str_new_lit(mrb, "#<Class:");
  ------------------
  |  | 1209|      0|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
 2301|       |
 2302|      0|    if (class_ptr_p(v)) {
  ------------------
  |  Branch (2302:9): [True: 0, False: 0]
  ------------------
 2303|      0|      mrb_str_cat_str(mrb, str, mrb_inspect(mrb, v));
 2304|      0|    }
 2305|      0|    else {
 2306|      0|      mrb_str_cat_str(mrb, str, mrb_any_to_s(mrb, v));
 2307|      0|    }
 2308|      0|    return mrb_str_cat_lit(mrb, str, ">");
  ------------------
  |  |  395|      0|#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
 2309|      0|  }
 2310|     92|  else {
 2311|     92|    return class_name_str(mrb, mrb_class_ptr(klass));
  ------------------
  |  |   24|     92|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|     92|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2312|     92|  }
 2313|     92|}
mrb_undef_method_id:
 2338|  1.74k|{
 2339|  1.74k|  if (!mrb_obj_respond_to(mrb, c, a)) {
  ------------------
  |  Branch (2339:7): [True: 0, False: 1.74k]
  ------------------
 2340|      0|    mrb_name_error(mrb, a, "undefined method '%n' for class '%C'", a, c);
 2341|      0|  }
 2342|  1.74k|  undef_method(mrb, c, a);
 2343|  1.74k|}
mrb_undef_method:
 2347|  29.6k|{
 2348|  29.6k|  undef_method(mrb, c, mrb_intern_cstr(mrb, name));
 2349|  29.6k|}
mrb_undef_class_method:
 2359|  22.6k|{
 2360|  22.6k|  mrb_undef_method(mrb,  mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
  ------------------
  |  |   24|  22.6k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  22.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2361|  22.6k|}
mrb_method_added:
 2545|   933k|{
 2546|   933k|  mrb_sym added;
 2547|   933k|  mrb_value recv = mrb_obj_value(c);
 2548|       |
 2549|   933k|  if (c->tt == MRB_TT_SCLASS) {
  ------------------
  |  Branch (2549:7): [True: 108k, False: 825k]
  ------------------
 2550|   108k|    added = MRB_SYM(singleton_method_added);
  ------------------
  |  |   18|   108k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2551|   108k|    recv = mrb_iv_get(mrb, recv, MRB_SYM(__attached__));
  ------------------
  |  |   18|   108k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2552|   108k|  }
 2553|   825k|  else {
 2554|   825k|    added = MRB_SYM(method_added);
  ------------------
  |  |   18|   825k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2555|   825k|  }
 2556|   933k|  if (!mrb_func_basic_p(mrb, recv, added, mrb_do_nothing)) {
  ------------------
  |  Branch (2556:7): [True: 0, False: 933k]
  ------------------
 2557|      0|    mrb_funcall_id(mrb, recv, added, 1, mrb_symbol_value(mid));
 2558|      0|  }
 2559|   933k|}
mrb_method_missing:
 2882|    126|{
 2883|    126|  mrb_no_method_error(mrb, name, args, "undefined method '%n'", name);
 2884|    126|}
mrb_init_class:
 2976|  1.74k|{
 2977|  1.74k|  struct RClass *bob;           /* BasicObject */
 2978|  1.74k|  struct RClass *obj;           /* Object */
 2979|  1.74k|  struct RClass *mod;           /* Module */
 2980|  1.74k|  struct RClass *cls;           /* Class */
 2981|       |
 2982|       |  /* boot class hierarchy */
 2983|  1.74k|  bob = boot_defclass(mrb, 0);
 2984|  1.74k|  obj = boot_defclass(mrb, bob); mrb->object_class = obj;
 2985|  1.74k|  mod = boot_defclass(mrb, obj); mrb->module_class = mod;/* obj -> mod */
 2986|  1.74k|  cls = boot_defclass(mrb, mod); mrb->class_class = cls; /* obj -> cls */
 2987|       |  /* fix-up loose ends */
 2988|  1.74k|  bob->c = obj->c = mod->c = cls->c = cls;
 2989|  1.74k|  make_metaclass(mrb, bob);
  ------------------
  |  |  362|  1.74k|#define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  ------------------
 2990|  1.74k|  make_metaclass(mrb, obj);
  ------------------
  |  |  362|  1.74k|#define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  ------------------
 2991|  1.74k|  make_metaclass(mrb, mod);
  ------------------
  |  |  362|  1.74k|#define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  ------------------
 2992|  1.74k|  make_metaclass(mrb, cls);
  ------------------
  |  |  362|  1.74k|#define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  ------------------
 2993|       |
 2994|       |  /* name basic classes */
 2995|  1.74k|  mrb_define_const_id(mrb, bob, MRB_SYM(BasicObject), mrb_obj_value(bob));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2996|  1.74k|  mrb_define_const_id(mrb, obj, MRB_SYM(Object),      mrb_obj_value(obj));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2997|  1.74k|  mrb_define_const_id(mrb, obj, MRB_SYM(Module),      mrb_obj_value(mod));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2998|  1.74k|  mrb_define_const_id(mrb, obj, MRB_SYM(Class),       mrb_obj_value(cls));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2999|       |
 3000|       |  /* name each classes */
 3001|  1.74k|  mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 3002|  1.74k|  mrb_class_name_class(mrb, NULL, obj, MRB_SYM(Object)); /* 15.2.1 */
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 3003|  1.74k|  mrb_class_name_class(mrb, NULL, mod, MRB_SYM(Module)); /* 15.2.2 */
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 3004|  1.74k|  mrb_class_name_class(mrb, NULL, cls, MRB_SYM(Class));  /* 15.2.3 */
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 3005|       |
 3006|  1.74k|  mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class);  /* 15.2.17 */
 3007|  1.74k|  MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 3008|       |
 3009|  1.74k|  MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 3010|  1.74k|  mrb_define_method(mrb, bob, "initialize",              mrb_do_nothing,           MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3011|  1.74k|  mrb_define_method(mrb, bob, "!",                       mrb_bob_not,              MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3012|  1.74k|  mrb_define_method(mrb, bob, "==",                      mrb_obj_equal_m,          MRB_ARGS_REQ(1)); /* 15.3.1.3.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3013|  1.74k|  mrb_define_method(mrb, bob, "__id__",                  mrb_obj_id_m,             MRB_ARGS_NONE()); /* 15.3.1.3.4  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3014|  1.74k|  mrb_define_method(mrb, bob, "__send__",                mrb_f_send,               MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK());  /* 15.3.1.3.5  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
                mrb_define_method(mrb, bob, "__send__",                mrb_f_send,               MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK());  /* 15.3.1.3.5  */
  ------------------
  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  ------------------
                mrb_define_method(mrb, bob, "__send__",                mrb_f_send,               MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK());  /* 15.3.1.3.5  */
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
 3015|  1.74k|  mrb_define_method(mrb, bob, "equal?",                  mrb_obj_equal_m,          MRB_ARGS_REQ(1)); /* 15.3.1.3.11 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3016|  1.74k|  mrb_define_method(mrb, bob, "instance_eval",           mrb_obj_instance_eval,    MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK());  /* 15.3.1.3.18 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
                mrb_define_method(mrb, bob, "instance_eval",           mrb_obj_instance_eval,    MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK());  /* 15.3.1.3.18 */
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
 3017|  1.74k|  mrb_define_method(mrb, bob, "singleton_method_added",  mrb_do_nothing,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3018|  1.74k|  mrb_define_method(mrb, bob, "method_missing",          mrb_obj_missing,          MRB_ARGS_ANY());  /* 15.3.1.3.30 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3019|       |
 3020|  1.74k|  mrb_define_class_method(mrb, cls, "new",               mrb_class_new_class,      MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK());
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
                mrb_define_class_method(mrb, cls, "new",               mrb_class_new_class,      MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
 3021|  1.74k|  mrb_define_method(mrb, cls, "allocate",                mrb_instance_alloc,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3022|  1.74k|  mrb_define_method(mrb, cls, "superclass",              mrb_class_superclass,     MRB_ARGS_NONE()); /* 15.2.3.3.4 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3023|  1.74k|  mrb_define_method(mrb, cls, "initialize",              mrb_class_initialize,     MRB_ARGS_OPT(1)); /* 15.2.3.3.1 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 3024|  1.74k|  mrb_define_method(mrb, cls, "inherited",               mrb_do_nothing,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3025|       |
 3026|  1.74k|  init_class_new(mrb, cls);
 3027|       |
 3028|  1.74k|  MRB_SET_INSTANCE_TT(mod, MRB_TT_MODULE);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 3029|  1.74k|  mrb_define_method(mrb, mod, "extend_object",           mrb_mod_extend_object,    MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3030|  1.74k|  mrb_define_method(mrb, mod, "extended",                mrb_do_nothing,           MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3031|  1.74k|  mrb_define_method(mrb, mod, "prepended",               mrb_do_nothing,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3032|  1.74k|  mrb_define_method(mrb, mod, "prepend_features",        mrb_mod_prepend_features, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3033|  1.74k|  mrb_define_method(mrb, mod, "include?",                mrb_mod_include_p,        MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3034|  1.74k|  mrb_define_method(mrb, mod, "append_features",         mrb_mod_append_features,  MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3035|  1.74k|  mrb_define_method(mrb, mod, "class_eval",              mrb_mod_module_eval,      MRB_ARGS_ANY());  /* 15.2.2.4.15 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3036|  1.74k|  mrb_define_method(mrb, mod, "included",                mrb_do_nothing,           MRB_ARGS_REQ(1)); /* 15.2.2.4.29 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3037|  1.74k|  mrb_define_method(mrb, mod, "initialize",              mrb_mod_initialize,       MRB_ARGS_NONE()); /* 15.2.2.4.31 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3038|  1.74k|  mrb_define_method(mrb, mod, "module_eval",             mrb_mod_module_eval,      MRB_ARGS_ANY());  /* 15.2.2.4.35 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3039|  1.74k|  mrb_define_method(mrb, mod, "module_function",         mrb_mod_module_function,  MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3040|  1.74k|  mrb_define_method(mrb, mod, "private",                 mrb_mod_dummy_visibility, MRB_ARGS_ANY());  /* 15.2.2.4.36 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3041|  1.74k|  mrb_define_method(mrb, mod, "protected",               mrb_mod_dummy_visibility, MRB_ARGS_ANY());  /* 15.2.2.4.37 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3042|  1.74k|  mrb_define_method(mrb, mod, "public",                  mrb_mod_dummy_visibility, MRB_ARGS_ANY());  /* 15.2.2.4.38 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3043|  1.74k|  mrb_define_method(mrb, mod, "attr_reader",             mrb_mod_attr_reader,      MRB_ARGS_ANY());  /* 15.2.2.4.13 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3044|  1.74k|  mrb_define_method(mrb, mod, "attr_writer",             mrb_mod_attr_writer,      MRB_ARGS_ANY());  /* 15.2.2.4.14 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3045|  1.74k|  mrb_define_method(mrb, mod, "to_s",                    mrb_mod_to_s,             MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3046|  1.74k|  mrb_define_method(mrb, mod, "inspect",                 mrb_mod_to_s,             MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3047|  1.74k|  mrb_define_method(mrb, mod, "alias_method",            mrb_mod_alias,            MRB_ARGS_ANY());  /* 15.2.2.4.8 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3048|  1.74k|  mrb_define_method(mrb, mod, "ancestors",               mrb_mod_ancestors,        MRB_ARGS_NONE()); /* 15.2.2.4.9 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3049|  1.74k|  mrb_define_method(mrb, mod, "undef_method",            mrb_mod_undef,            MRB_ARGS_ANY());  /* 15.2.2.4.41 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3050|  1.74k|  mrb_define_method(mrb, mod, "const_defined?",          mrb_mod_const_defined,    MRB_ARGS_ARG(1,1)); /* 15.2.2.4.20 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3051|  1.74k|  mrb_define_method(mrb, mod, "const_get",               mrb_mod_const_get,        MRB_ARGS_REQ(1)); /* 15.2.2.4.21 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3052|  1.74k|  mrb_define_method(mrb, mod, "const_set",               mrb_mod_const_set,        MRB_ARGS_REQ(2)); /* 15.2.2.4.23 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3053|  1.74k|  mrb_define_method(mrb, mod, "remove_const",            mrb_mod_remove_const,     MRB_ARGS_REQ(1)); /* 15.2.2.4.40 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3054|  1.74k|  mrb_define_method(mrb, mod, "const_missing",           mrb_mod_const_missing,    MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3055|  1.74k|  mrb_define_method(mrb, mod, "method_defined?",         mrb_mod_method_defined,   MRB_ARGS_REQ(1)); /* 15.2.2.4.34 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3056|  1.74k|  mrb_define_method(mrb, mod, "define_method",           mod_define_method,        MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3057|  1.74k|  mrb_define_method(mrb, mod, "===",                     mrb_mod_eqq,              MRB_ARGS_REQ(1)); /* 15.2.2.4.7 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3058|  1.74k|  mrb_define_method(mrb, mod, "dup",                     mrb_mod_dup,              MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3059|  1.74k|  mrb_define_method(mrb, mod, "method_added",            mrb_do_nothing,           MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3060|       |
 3061|  1.74k|  mrb_undef_method(mrb, cls, "append_features");
 3062|  1.74k|  mrb_undef_method(mrb, cls, "prepend_features");
 3063|  1.74k|  mrb_undef_method(mrb, cls, "extend_object");
 3064|  1.74k|  mrb_undef_method(mrb, cls, "module_function");
 3065|       |
 3066|  1.74k|  mrb->top_self = MRB_OBJ_ALLOC(mrb, MRB_TT_OBJECT, mrb->object_class);
  ------------------
  |  | 1200|  1.74k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 3067|  1.74k|  mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3068|  1.74k|  mrb_define_singleton_method(mrb, mrb->top_self, "to_s", inspect_main, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3069|  1.74k|  mrb_define_singleton_method(mrb, mrb->top_self, "define_method", top_define_method, MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3070|  1.74k|}
class.c:create_method_value:
  248|   525k|{
  249|   525k|  mrb_method_t m;
  250|       |
  251|   525k|  if (key & MT_FUNC_P) {
  ------------------
  |  |   28|   525k|#define MT_FUNC_P 1
  ------------------
  |  Branch (251:7): [True: 339k, False: 185k]
  ------------------
  252|   339k|    MRB_METHOD_FROM_FUNC(m, val.func);
  ------------------
  |  |  111|   339k|#define MRB_METHOD_FROM_FUNC(m,fn) ((m)=(mrb_method_t)((((uintptr_t)(fn))<<2)|MRB_METHOD_FUNC_FL))
  |  |  ------------------
  |  |  |  |  102|   339k|#define MRB_METHOD_FUNC_FL 1
  |  |  ------------------
  ------------------
  253|   339k|  }
  254|   185k|  else {
  255|   185k|    MRB_METHOD_FROM_PROC(m, val.proc);
  ------------------
  |  |  112|   185k|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
  256|   185k|  }
  257|   525k|  if (key & MT_NOARG_P) {
  ------------------
  |  |   29|   525k|#define MT_NOARG_P 2
  ------------------
  |  Branch (257:7): [True: 73.2k, False: 452k]
  ------------------
  258|  73.2k|    MRB_METHOD_NOARG_SET(m);
  ------------------
  |  |  109|  73.2k|#define MRB_METHOD_NOARG_SET(m) ((m)=(mrb_method_t)(((uintptr_t)(m))|MRB_METHOD_NOARG_FL))
  |  |  ------------------
  |  |  |  |  103|  73.2k|#define MRB_METHOD_NOARG_FL 2
  |  |  ------------------
  ------------------
  259|  73.2k|  }
  260|   525k|  return m;
  261|   525k|}
class.c:mt_free:
  241|   223k|{
  242|   223k|  mrb_free(mrb, t->ptr);
  243|   223k|  mrb_free(mrb, t);
  244|   223k|}
class.c:define_module:
  455|  17.4k|{
  456|  17.4k|  struct RClass *m;
  457|       |
  458|  17.4k|  if (mrb_const_defined_at(mrb, mrb_obj_value(outer), name)) {
  ------------------
  |  Branch (458:7): [True: 0, False: 17.4k]
  ------------------
  459|      0|    return module_from_sym(mrb, outer, name);
  460|      0|  }
  461|  17.4k|  m = mrb_module_new(mrb);
  462|  17.4k|  setup_class(mrb, outer, m, name);
  463|       |
  464|  17.4k|  return m;
  465|  17.4k|}
class.c:check_if_class_or_module:
  447|   143k|{
  448|   143k|  if (!class_ptr_p(obj)) {
  ------------------
  |  Branch (448:7): [True: 0, False: 143k]
  ------------------
  449|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a class/module", obj);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  450|      0|  }
  451|   143k|}
class.c:setup_class:
  357|   148k|{
  358|   148k|  mrb_class_name_class(mrb, outer, c, id);
  359|   148k|  mrb_obj_iv_set(mrb, (struct RObject*)outer, id, mrb_obj_value(c));
  360|   148k|}
class.c:define_class:
  522|   123k|{
  523|   123k|  struct RClass * c;
  524|       |
  525|   123k|  if (mrb_const_defined_at(mrb, mrb_obj_value(outer), name)) {
  ------------------
  |  Branch (525:7): [True: 1.74k, False: 122k]
  ------------------
  526|  1.74k|    c = class_from_sym(mrb, outer, name);
  527|  1.74k|    MRB_CLASS_ORIGIN(c);
  ------------------
  |  |   65|  1.74k|#define MRB_CLASS_ORIGIN(c) do {\
  |  |   66|  1.74k|  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
  |  |  ------------------
  |  |  |  |   63|  1.74k|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  |  |  ------------------
  |  |  |  Branch (66:7): [True: 0, False: 1.74k]
  |  |  ------------------
  |  |   67|      0|    (c) = (c)->super;\
  |  |   68|      0|    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
  |  |  ------------------
  |  |  |  Branch (68:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|      (c) = (c)->super;\
  |  |   70|      0|    }\
  |  |   71|      0|  }\
  |  |   72|  1.74k|} while (0)
  |  |  ------------------
  |  |  |  Branch (72:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  528|  1.74k|    if (super && mrb_class_real(c->super) != super) {
  ------------------
  |  Branch (528:9): [True: 1.74k, False: 0]
  |  Branch (528:18): [True: 0, False: 1.74k]
  ------------------
  529|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for Class %n (%C not %C)",
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  530|      0|                 name, c->super, super);
  531|      0|    }
  532|  1.74k|    return c;
  533|  1.74k|  }
  534|       |
  535|   122k|  c = mrb_class_new(mrb, super);
  536|   122k|  setup_class(mrb, outer, c, name);
  537|       |
  538|   122k|  return c;
  539|   123k|}
class.c:mrb_class_inherited:
  567|  41.8k|{
  568|  41.8k|  mrb_value s;
  569|  41.8k|  mrb_sym mid;
  570|       |
  571|  41.8k|  if (!super)
  ------------------
  |  Branch (571:7): [True: 0, False: 41.8k]
  ------------------
  572|      0|    super = mrb->object_class;
  573|  41.8k|  super->flags |= MRB_FL_CLASS_IS_INHERITED;
  ------------------
  |  |   73|  41.8k|#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
  ------------------
  574|  41.8k|  s = mrb_obj_value(super);
  575|  41.8k|  mid = MRB_SYM(inherited);
  ------------------
  |  |   18|  41.8k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  576|  41.8k|  if (!mrb_func_basic_p(mrb, s, mid, mrb_do_nothing)) {
  ------------------
  |  Branch (576:7): [True: 0, False: 41.8k]
  ------------------
  577|      0|    mrb_value c = mrb_obj_value(klass);
  578|      0|    mrb_funcall_argv(mrb, s, mid, 1, &c);
  579|      0|  }
  580|  41.8k|}
class.c:class_from_sym:
  416|  19.1k|{
  417|  19.1k|  mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
  418|       |
  419|  19.1k|  mrb_check_type(mrb, c, MRB_TT_CLASS);
  420|  19.1k|  return mrb_class_ptr(c);
  ------------------
  |  |   24|  19.1k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  19.1k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  421|  19.1k|}
class.c:module_from_sym:
  425|  6.98k|{
  426|  6.98k|  mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
  427|       |
  428|  6.98k|  mrb_check_type(mrb, c, MRB_TT_MODULE);
  429|  6.98k|  return mrb_class_ptr(c);
  ------------------
  |  |   24|  6.98k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  6.98k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  430|  6.98k|}
class.c:mt_new:
   53|   223k|{
   54|   223k|  mt_tbl *t;
   55|       |
   56|   223k|  t = (mt_tbl*)mrb_malloc(mrb, sizeof(mt_tbl));
   57|   223k|  t->size = 0;
   58|   223k|  t->alloc = 0;
   59|   223k|  t->ptr = NULL;
   60|       |
   61|   223k|  return t;
   62|   223k|}
class.c:mt_put:
   97|  4.82M|{
   98|  4.82M|  int hash, pos, start, dpos = -1;
   99|       |
  100|  4.82M|  if (t->alloc == 0) {
  ------------------
  |  Branch (100:7): [True: 170k, False: 4.65M]
  ------------------
  101|   170k|    mt_rehash(mrb, t);
  102|   170k|  }
  103|       |
  104|  4.82M|  mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
  105|  4.82M|  union mt_ptr *vals = t->ptr;
  106|  4.82M|  hash = kh_int_hash_func(mrb, sym);
  ------------------
  |  |  267|  4.82M|#define kh_int_hash_func(mrb,key) (khint_t)((key)^((key)<<2)^((key)>>2))
  ------------------
  107|  4.82M|  start = pos = hash & (t->alloc-1);
  108|  15.4M|  for (;;) {
  109|  15.4M|    mrb_sym key = keys[pos];
  110|  15.4M|    if (MT_KEY_SYM(key) == sym) {
  ------------------
  |  |   35|  15.4M|#define MT_KEY_SYM(k) ((k)>>2)
  ------------------
  |  Branch (110:9): [True: 27.9k, False: 15.4M]
  ------------------
  111|  4.82M|    value_set:
  112|  4.82M|      keys[pos] = MT_KEY(sym, flags);
  ------------------
  |  |   33|  4.82M|#define MT_KEY(sym, flags) ((sym)<<2|(flags))
  ------------------
  113|  4.82M|      vals[pos] = ptr;
  114|  4.82M|      return;
  115|  27.9k|    }
  116|  15.4M|    else if (key == MT_EMPTY) {
  ------------------
  |  |   30|  15.4M|#define MT_EMPTY 0
  ------------------
  |  Branch (116:14): [True: 4.79M, False: 10.6M]
  ------------------
  117|  4.79M|      t->size++;
  118|  4.79M|      goto value_set;
  119|  4.79M|    }
  120|  10.6M|    else if (key == MT_DELETED && dpos < 0) {
  ------------------
  |  |   31|  21.2M|#define MT_DELETED 1
  ------------------
  |  Branch (120:14): [True: 0, False: 10.6M]
  |  Branch (120:35): [True: 0, False: 0]
  ------------------
  121|      0|      dpos = pos;
  122|      0|    }
  123|  10.6M|    pos = (pos+1) & (t->alloc-1);
  124|  10.6M|    if (pos == start) {         /* not found */
  ------------------
  |  Branch (124:9): [True: 148k, False: 10.4M]
  ------------------
  125|   148k|      if (dpos > 0) {
  ------------------
  |  Branch (125:11): [True: 0, False: 148k]
  ------------------
  126|      0|        t->size++;
  127|      0|        pos = dpos;
  128|      0|        goto value_set;
  129|      0|      }
  130|       |      /* no room */
  131|   148k|      mt_rehash(mrb, t);
  132|   148k|      start = pos = hash & (t->alloc-1);
  133|   148k|      keys = (mrb_sym*)&t->ptr[t->alloc];
  134|   148k|      vals = t->ptr;
  135|   148k|    }
  136|  10.6M|  }
  137|  4.82M|}
class.c:mt_rehash:
   68|   319k|{
   69|   319k|  int old_alloc = t->alloc;
   70|   319k|  int new_alloc = old_alloc+8;
   71|   319k|  union mt_ptr *old_ptr = t->ptr;
   72|       |
   73|   319k|  khash_power2(new_alloc);
  ------------------
  |  |   41|   319k|#define khash_power2(v) do { \
  |  |   42|   319k|  v--;\
  |  |   43|   319k|  v |= v >> 1;\
  |  |   44|   319k|  v |= v >> 2;\
  |  |   45|   319k|  v |= v >> 4;\
  |  |   46|   319k|  v |= v >> 8;\
  |  |   47|   319k|  v |= v >> 16;\
  |  |   48|   319k|  v++;\
  |  |   49|   319k|} while (0)
  |  |  ------------------
  |  |  |  Branch (49:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   74|   319k|  if (old_alloc == new_alloc) return;
  ------------------
  |  Branch (74:7): [True: 0, False: 319k]
  ------------------
   75|       |
   76|   319k|  t->ptr = (union mt_ptr*)mrb_calloc(mrb, sizeof(union mt_ptr)+sizeof(mrb_sym), new_alloc);
   77|   319k|  t->alloc = new_alloc;
   78|   319k|  t->size = 0;
   79|   319k|  if (old_alloc == 0) return;
  ------------------
  |  Branch (79:7): [True: 170k, False: 148k]
  ------------------
   80|       |
   81|   148k|  mrb_sym *keys = (mrb_sym*)&old_ptr[old_alloc];
   82|   148k|  union mt_ptr *vals = old_ptr;
   83|  2.56M|  for (int i = 0; i < old_alloc; i++) {
  ------------------
  |  Branch (83:19): [True: 2.41M, False: 148k]
  ------------------
   84|  2.41M|    mrb_sym key = keys[i];
   85|  2.41M|    if (MT_KEY_P(key)) {
  ------------------
  |  |   27|  2.41M|#define MT_KEY_P(k) (((k)>>2) != 0)
  |  |  ------------------
  |  |  |  Branch (27:21): [True: 2.41M, False: 0]
  |  |  ------------------
  ------------------
   86|  2.41M|      mt_put(mrb, t, MT_KEY_SYM(key), MT_KEY_FLG(key), vals[i]);
  ------------------
  |  |   35|  2.41M|#define MT_KEY_SYM(k) ((k)>>2)
  ------------------
                    mt_put(mrb, t, MT_KEY_SYM(key), MT_KEY_FLG(key), vals[i]);
  ------------------
  |  |   36|  2.41M|#define MT_KEY_FLG(k) ((k)&3)
  ------------------
   87|  2.41M|    }
   88|  2.41M|  }
   89|   148k|  mrb_free(mrb, old_ptr);
   90|   148k|}
class.c:get_args_v:
  908|   161k|{
  909|   161k|  const char *fmt = format;
  910|   161k|  char c;
  911|   161k|  mrb_int i = 0;
  912|   161k|  mrb_callinfo *ci = mrb->c->ci;
  913|   161k|  mrb_int argc = ci->n;
  914|   161k|  const mrb_value *argv = ci->stack+1;
  915|   161k|  mrb_bool argv_on_stack;
  916|   161k|  mrb_bool opt = FALSE;
  ------------------
  |  |   51|   161k|#  define FALSE 0
  ------------------
  917|   161k|  mrb_bool opt_skip = TRUE;
  ------------------
  |  |   54|   161k|#  define TRUE 1
  ------------------
  918|   161k|  const mrb_value *pickarg = NULL; /* arguments currently being processed */
  919|   161k|  mrb_value kdict = mrb_nil_value();
  920|   161k|  mrb_bool reqkarg = FALSE;
  ------------------
  |  |   51|   161k|#  define FALSE 0
  ------------------
  921|   161k|  int argc_min = 0, argc_max = 0;
  922|       |
  923|   395k|  while ((c = *fmt++)) {
  ------------------
  |  Branch (923:10): [True: 262k, False: 133k]
  ------------------
  924|   262k|    switch (c) {
  925|  36.3k|    case '|':
  ------------------
  |  Branch (925:5): [True: 36.3k, False: 226k]
  ------------------
  926|  36.3k|      opt = TRUE;
  ------------------
  |  |   54|  36.3k|#  define TRUE 1
  ------------------
  927|  36.3k|      break;
  928|  27.9k|    case '*':
  ------------------
  |  Branch (928:5): [True: 27.9k, False: 234k]
  ------------------
  929|  27.9k|      opt_skip = FALSE;
  ------------------
  |  |   51|  27.9k|#  define FALSE 0
  ------------------
  930|  27.9k|      argc_max = -1;
  931|  27.9k|      if (!reqkarg) reqkarg = strchr(fmt, ':') ? TRUE : FALSE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
                    if (!reqkarg) reqkarg = strchr(fmt, ':') ? TRUE : FALSE;
  ------------------
  |  |   51|  27.9k|#  define FALSE 0
  ------------------
  |  Branch (931:11): [True: 27.9k, False: 0]
  |  Branch (931:31): [True: 0, False: 27.9k]
  ------------------
  932|  27.9k|      goto check_exit;
  933|      0|    case '!':
  ------------------
  |  Branch (933:5): [True: 0, False: 262k]
  ------------------
  934|      0|    case '+':
  ------------------
  |  Branch (934:5): [True: 0, False: 262k]
  ------------------
  935|      0|      break;
  936|      0|    case ':':
  ------------------
  |  Branch (936:5): [True: 0, False: 262k]
  ------------------
  937|      0|      reqkarg = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  938|       |      /* fall through */
  939|  1.74k|    case '&': case '?':
  ------------------
  |  Branch (939:5): [True: 1.74k, False: 260k]
  |  Branch (939:15): [True: 0, False: 262k]
  ------------------
  940|  1.74k|      if (opt) opt_skip = FALSE;
  ------------------
  |  |   51|  1.74k|#  define FALSE 0
  ------------------
  |  Branch (940:11): [True: 1.74k, False: 0]
  ------------------
  941|  1.74k|      break;
  942|   196k|    default:
  ------------------
  |  Branch (942:5): [True: 196k, False: 66.0k]
  ------------------
  943|   196k|      if (!opt) argc_min++;
  ------------------
  |  Branch (943:11): [True: 135k, False: 60.5k]
  ------------------
  944|   196k|      argc_max++;
  945|   196k|      break;
  946|   262k|    }
  947|   262k|  }
  948|       |
  949|   161k| check_exit:
  950|   161k|  if (!reqkarg && ci->nk > 0) {
  ------------------
  |  Branch (950:7): [True: 161k, False: 0]
  |  Branch (950:19): [True: 5.25k, False: 155k]
  ------------------
  951|  5.25k|    mrb_assert(ci->nk == 15);
  ------------------
  |  |   68|  5.25k|#define mrb_assert(p) ((void)0)
  ------------------
  952|  5.25k|    kdict = ci->stack[mrb_ci_bidx(ci)-1];
  953|  5.25k|    if (mrb_hash_p(kdict) && mrb_hash_size(mrb, kdict) > 0) {
  ------------------
  |  |  188|  5.25k|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|  10.5k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  10.5k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  10.5k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 5.25k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 5.25k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 5.25k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (953:30): [True: 0, False: 5.25k]
  ------------------
  954|      0|      if (argc < 14) {
  ------------------
  |  Branch (954:11): [True: 0, False: 0]
  ------------------
  955|      0|        ci->n++;
  956|      0|        argc++;    /* include kdict in normal arguments */
  957|      0|      }
  958|      0|      else {
  959|       |        /* 14+1 == 15 so pack first */
  960|      0|        if (argc == 14) {
  ------------------
  |  Branch (960:13): [True: 0, False: 0]
  ------------------
  961|       |          /* pack arguments and kdict */
  962|      0|          ci->stack[1] = mrb_ary_new_from_values(mrb, argc+1, &ci->stack[1]);
  963|      0|          argc = ci->n = 15;
  964|      0|        }
  965|      0|        else {
  966|       |          /* push kdict to packed arguments */
  967|      0|          mrb_ary_push(mrb, ci->stack[1], kdict);
  968|      0|        }
  969|      0|        ci->stack[2] = ci->stack[mrb_ci_bidx(ci)];
  970|      0|      }
  971|      0|      ci->nk = 0;
  972|      0|    }
  973|  5.25k|  }
  974|   161k|  if (reqkarg && ci->nk > 0) {
  ------------------
  |  Branch (974:7): [True: 0, False: 161k]
  |  Branch (974:18): [True: 0, False: 0]
  ------------------
  975|      0|    kdict = ci->stack[mrb_ci_bidx(ci)-1];
  976|      0|    mrb_assert(ci->nk == 15);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
  977|      0|    mrb_assert(mrb_hash_p(kdict));
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
  978|      0|  }
  979|       |
  980|   161k|  argv_on_stack = argc < 15;
  981|   161k|  if (!argv_on_stack) {
  ------------------
  |  Branch (981:7): [True: 22.7k, False: 138k]
  ------------------
  982|  22.7k|    struct RArray *a = mrb_ary_ptr(*argv);
  ------------------
  |  |   51|  22.7k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  22.7k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  983|  22.7k|    argv = ARY_PTR(a);
  ------------------
  |  |   71|  22.7k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  22.7k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  22.7k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 19.2k, False: 3.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  19.2k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  984|  22.7k|    argc = ARY_LEN(a);
  ------------------
  |  |   70|  22.7k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  22.7k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  22.7k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 19.2k, False: 3.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  19.2k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  19.2k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  985|  22.7k|  }
  986|       |
  987|   161k|  opt = FALSE;
  ------------------
  |  |   51|   161k|#  define FALSE 0
  ------------------
  988|   161k|  i = 0;
  989|   353k|  while ((c = *format++)) {
  ------------------
  |  Branch (989:10): [True: 218k, False: 135k]
  ------------------
  990|   218k|    mrb_bool altmode = FALSE;
  ------------------
  |  |   51|   218k|#  define FALSE 0
  ------------------
  991|   218k|    mrb_bool needmodify = FALSE;
  ------------------
  |  |   51|   218k|#  define FALSE 0
  ------------------
  992|       |
  993|   218k|    for (; *format; format++) {
  ------------------
  |  Branch (993:12): [True: 82.5k, False: 135k]
  ------------------
  994|  82.5k|      switch (*format) {
  995|      0|      case '!':
  ------------------
  |  Branch (995:7): [True: 0, False: 82.5k]
  ------------------
  996|      0|        if (altmode) goto modifier_exit; /* not accept for multiple '!' */
  ------------------
  |  Branch (996:13): [True: 0, False: 0]
  ------------------
  997|      0|        altmode = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  998|      0|        break;
  999|      0|      case '+':
  ------------------
  |  Branch (999:7): [True: 0, False: 82.5k]
  ------------------
 1000|      0|        if (needmodify) goto modifier_exit; /* not accept for multiple '+' */
  ------------------
  |  Branch (1000:13): [True: 0, False: 0]
  ------------------
 1001|      0|        needmodify = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 1002|      0|        break;
 1003|  82.5k|      default:
  ------------------
  |  Branch (1003:7): [True: 82.5k, False: 0]
  ------------------
 1004|  82.5k|        goto modifier_exit;
 1005|  82.5k|      }
 1006|  82.5k|    }
 1007|       |
 1008|   218k|  modifier_exit:
 1009|   218k|    switch (c) {
 1010|  66.0k|    case '|': case '*': case '&': case '?': case ':':
  ------------------
  |  Branch (1010:5): [True: 36.3k, False: 181k]
  |  Branch (1010:15): [True: 27.9k, False: 190k]
  |  Branch (1010:25): [True: 1.74k, False: 216k]
  |  Branch (1010:35): [True: 0, False: 218k]
  |  Branch (1010:45): [True: 0, False: 218k]
  ------------------
 1011|  66.0k|      if (needmodify) {
  ------------------
  |  Branch (1011:11): [True: 0, False: 66.0k]
  ------------------
 1012|      0|      bad_needmodify:
 1013|      0|        mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong `%c+` modified specifier`", c);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1014|      0|      }
 1015|  66.0k|      break;
 1016|   152k|    default:
  ------------------
  |  Branch (1016:5): [True: 152k, False: 66.0k]
  ------------------
 1017|   152k|      if (i < argc) {
  ------------------
  |  Branch (1017:11): [True: 145k, False: 6.98k]
  ------------------
 1018|   145k|        pickarg = &argv[i++];
 1019|   145k|        if (needmodify && !mrb_nil_p(*pickarg)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
  |  Branch (1019:13): [True: 0, False: 145k]
  |  Branch (1019:27): [True: 0, False: 0]
  ------------------
 1020|      0|          mrb_check_frozen_value(mrb, *pickarg);
 1021|      0|        }
 1022|   145k|      }
 1023|  6.98k|      else {
 1024|  6.98k|        if (opt) {
  ------------------
  |  Branch (1024:13): [True: 6.98k, False: 0]
  ------------------
 1025|  6.98k|          pickarg = NULL;
 1026|  6.98k|        }
 1027|      0|        else {
 1028|      0|          mrb_argnum_error(mrb, argc, argc_min, argc_max);
 1029|      0|        }
 1030|  6.98k|      }
 1031|   152k|      break;
 1032|   218k|    }
 1033|       |
 1034|   218k|    switch (c) {
 1035|  17.5k|    case 'o':
  ------------------
  |  Branch (1035:5): [True: 17.5k, False: 200k]
  ------------------
 1036|  17.5k|    case 'C':
  ------------------
  |  Branch (1036:5): [True: 0, False: 218k]
  ------------------
 1037|  19.3k|    case 'S':
  ------------------
  |  Branch (1037:5): [True: 1.74k, False: 216k]
  ------------------
 1038|  30.6k|    case 'A':
  ------------------
  |  Branch (1038:5): [True: 11.3k, False: 206k]
  ------------------
 1039|  38.6k|    case 'H':
  ------------------
  |  Branch (1039:5): [True: 8.01k, False: 210k]
  ------------------
 1040|  38.6k|      {
 1041|  38.6k|        mrb_value *p;
 1042|       |
 1043|  38.6k|        p = GET_ARG(mrb_value*);
  ------------------
  |  |  904|  38.6k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 38.6k]
  |  |  ------------------
  ------------------
 1044|  38.6k|        if (pickarg) {
  ------------------
  |  Branch (1044:13): [True: 31.6k, False: 6.98k]
  ------------------
 1045|  31.6k|          if (!(altmode && mrb_nil_p(*pickarg))) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1045:17): [True: 0, False: 31.6k]
  ------------------
 1046|  31.6k|            switch (c) {
  ------------------
  |  Branch (1046:21): [True: 17.5k, False: 14.1k]
  ------------------
 1047|      0|            case 'C': ensure_class_type(mrb, *pickarg); break;
  ------------------
  |  Branch (1047:13): [True: 0, False: 31.6k]
  ------------------
 1048|      0|            case 'S': mrb_ensure_string_type(mrb, *pickarg); break;
  ------------------
  |  Branch (1048:13): [True: 0, False: 31.6k]
  ------------------
 1049|  11.3k|            case 'A': mrb_ensure_array_type(mrb, *pickarg); break;
  ------------------
  |  Branch (1049:13): [True: 11.3k, False: 20.3k]
  ------------------
 1050|  2.77k|            case 'H': mrb_ensure_hash_type(mrb, *pickarg); break;
  ------------------
  |  Branch (1050:13): [True: 2.77k, False: 28.9k]
  ------------------
 1051|  31.6k|            }
 1052|  31.6k|          }
 1053|  31.6k|          *p = *pickarg;
 1054|  31.6k|        }
 1055|  38.6k|      }
 1056|  38.6k|      break;
 1057|  63.5k|    case 'c':
  ------------------
  |  Branch (1057:5): [True: 63.5k, False: 154k]
  ------------------
 1058|  63.5k|      {
 1059|  63.5k|        struct RClass **p;
 1060|       |
 1061|  63.5k|        p = GET_ARG(struct RClass**);
  ------------------
  |  |  904|  63.5k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 63.5k]
  |  |  ------------------
  ------------------
 1062|  63.5k|        if (pickarg) {
  ------------------
  |  Branch (1062:13): [True: 63.5k, False: 0]
  ------------------
 1063|  63.5k|          if (altmode && mrb_nil_p(*pickarg)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1063:15): [True: 0, False: 63.5k]
  ------------------
 1064|      0|            *p = NULL;
 1065|      0|          }
 1066|  63.5k|          else {
 1067|  63.5k|            ensure_class_type(mrb, *pickarg);
 1068|  63.5k|            *p = mrb_class_ptr(*pickarg);
  ------------------
  |  |   24|  63.5k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  63.5k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1069|  63.5k|          }
 1070|  63.5k|        }
 1071|  63.5k|      }
 1072|  63.5k|      break;
 1073|      0|    case 's':
  ------------------
  |  Branch (1073:5): [True: 0, False: 218k]
  ------------------
 1074|      0|      {
 1075|      0|        const char **ps = NULL;
 1076|      0|        mrb_int *pl = NULL;
 1077|       |
 1078|      0|        ps = GET_ARG(const char**);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1079|      0|        pl = GET_ARG(mrb_int*);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1080|      0|        if (needmodify) goto bad_needmodify;
  ------------------
  |  Branch (1080:13): [True: 0, False: 0]
  ------------------
 1081|      0|        if (pickarg) {
  ------------------
  |  Branch (1081:13): [True: 0, False: 0]
  ------------------
 1082|      0|          if (altmode && mrb_nil_p(*pickarg)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1082:15): [True: 0, False: 0]
  ------------------
 1083|      0|            *ps = NULL;
 1084|      0|            *pl = 0;
 1085|      0|          }
 1086|      0|          else {
 1087|      0|            mrb_ensure_string_type(mrb, *pickarg);
 1088|      0|            *ps = RSTRING_PTR(*pickarg);
  ------------------
  |  |  100|      0|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1089|      0|            *pl = RSTRING_LEN(*pickarg);
  ------------------
  |  |  102|      0|#define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
  |  |  ------------------
  |  |  |  |   66|      0|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|      0|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  113|      0|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  112|      0|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      0|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:22): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1090|      0|          }
 1091|      0|        }
 1092|      0|      }
 1093|      0|      break;
 1094|      0|    case 'z':
  ------------------
  |  Branch (1094:5): [True: 0, False: 218k]
  ------------------
 1095|      0|      {
 1096|      0|        const char **ps;
 1097|       |
 1098|      0|        ps = GET_ARG(const char**);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1099|      0|        if (needmodify) goto bad_needmodify;
  ------------------
  |  Branch (1099:13): [True: 0, False: 0]
  ------------------
 1100|      0|        if (pickarg) {
  ------------------
  |  Branch (1100:13): [True: 0, False: 0]
  ------------------
 1101|      0|          if (altmode && mrb_nil_p(*pickarg)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1101:15): [True: 0, False: 0]
  ------------------
 1102|      0|            *ps = NULL;
 1103|      0|          }
 1104|      0|          else {
 1105|      0|            mrb_ensure_string_type(mrb, *pickarg);
 1106|      0|            *ps = RSTRING_CSTR(mrb, *pickarg);
  ------------------
  |  |  105|      0|#define RSTRING_CSTR(mrb,s)  mrb_string_cstr(mrb, s)
  ------------------
 1107|      0|          }
 1108|      0|        }
 1109|      0|      }
 1110|      0|      break;
 1111|      0|    case 'a':
  ------------------
  |  Branch (1111:5): [True: 0, False: 218k]
  ------------------
 1112|      0|      {
 1113|      0|        struct RArray *a;
 1114|      0|        const mrb_value **pb;
 1115|      0|        mrb_int *pl;
 1116|       |
 1117|      0|        pb = GET_ARG(const mrb_value**);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1118|      0|        pl = GET_ARG(mrb_int*);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1119|      0|        if (needmodify) goto bad_needmodify;
  ------------------
  |  Branch (1119:13): [True: 0, False: 0]
  ------------------
 1120|      0|        if (pickarg) {
  ------------------
  |  Branch (1120:13): [True: 0, False: 0]
  ------------------
 1121|      0|          if (altmode && mrb_nil_p(*pickarg)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1121:15): [True: 0, False: 0]
  ------------------
 1122|      0|            *pb = NULL;
 1123|      0|            *pl = 0;
 1124|      0|          }
 1125|      0|          else {
 1126|      0|            mrb_ensure_array_type(mrb, *pickarg);
 1127|      0|            a = mrb_ary_ptr(*pickarg);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1128|      0|            *pb = ARY_PTR(a);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 1129|      0|            *pl = ARY_LEN(a);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1130|      0|          }
 1131|      0|        }
 1132|      0|      }
 1133|      0|      break;
 1134|      0|#ifndef MRB_NO_FLOAT
 1135|  1.53k|    case 'f':
  ------------------
  |  Branch (1135:5): [True: 1.53k, False: 216k]
  ------------------
 1136|  1.53k|      {
 1137|  1.53k|        mrb_float *p;
 1138|       |
 1139|  1.53k|        p = GET_ARG(mrb_float*);
  ------------------
  |  |  904|  1.53k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 1.53k]
  |  |  ------------------
  ------------------
 1140|  1.53k|        if (pickarg) {
  ------------------
  |  Branch (1140:13): [True: 1.53k, False: 0]
  ------------------
 1141|  1.53k|          *p = mrb_as_float(mrb, *pickarg);
  ------------------
  |  | 1297|  1.53k|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|  1.53k|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 1142|  1.53k|        }
 1143|  1.53k|      }
 1144|  1.53k|      break;
 1145|      0|#endif
 1146|  10.1k|    case 'i':
  ------------------
  |  Branch (1146:5): [True: 10.1k, False: 207k]
  ------------------
 1147|  10.1k|      {
 1148|  10.1k|        mrb_int *p;
 1149|       |
 1150|  10.1k|        p = GET_ARG(mrb_int*);
  ------------------
  |  |  904|  10.1k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 10.1k]
  |  |  ------------------
  ------------------
 1151|  10.1k|        if (pickarg) {
  ------------------
  |  Branch (1151:13): [True: 10.1k, False: 0]
  ------------------
 1152|  10.1k|          *p = mrb_as_int(mrb, *pickarg);
  ------------------
  |  | 1425|  10.1k|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|  10.1k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
 1153|  10.1k|        }
 1154|  10.1k|      }
 1155|  10.1k|      break;
 1156|  1.52k|    case 'b':
  ------------------
  |  Branch (1156:5): [True: 1.52k, False: 216k]
  ------------------
 1157|  1.52k|      {
 1158|  1.52k|        mrb_bool *boolp = GET_ARG(mrb_bool*);
  ------------------
  |  |  904|  1.52k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 1.52k]
  |  |  ------------------
  ------------------
 1159|       |
 1160|  1.52k|        if (pickarg) {
  ------------------
  |  Branch (1160:13): [True: 1.52k, False: 0]
  ------------------
 1161|  1.52k|          *boolp = mrb_test(*pickarg);
  ------------------
  |  |  312|  1.52k|#define mrb_test(o)   mrb_bool(o)
  |  |  ------------------
  |  |  |  |  168|  1.52k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  |  |  ------------------
  ------------------
 1162|  1.52k|        }
 1163|  1.52k|      }
 1164|  1.52k|      break;
 1165|  36.6k|    case 'n':
  ------------------
  |  Branch (1165:5): [True: 36.6k, False: 181k]
  ------------------
 1166|  36.6k|      {
 1167|  36.6k|        mrb_sym *symp;
 1168|       |
 1169|  36.6k|        symp = GET_ARG(mrb_sym*);
  ------------------
  |  |  904|  36.6k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 36.6k]
  |  |  ------------------
  ------------------
 1170|  36.6k|        if (pickarg) {
  ------------------
  |  Branch (1170:13): [True: 36.6k, False: 0]
  ------------------
 1171|  36.6k|          *symp = to_sym(mrb, *pickarg);
  ------------------
  |  |  844|  36.6k|#define to_sym(mrb, ss) mrb_obj_to_sym(mrb, ss)
  ------------------
 1172|  36.6k|        }
 1173|  36.6k|      }
 1174|  36.6k|      break;
 1175|      0|    case 'd':
  ------------------
  |  Branch (1175:5): [True: 0, False: 218k]
  ------------------
 1176|      0|      {
 1177|      0|        void** datap;
 1178|      0|        struct mrb_data_type const* type;
 1179|       |
 1180|      0|        datap = GET_ARG(void**);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1181|      0|        type = GET_ARG(struct mrb_data_type const*);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1182|      0|        if (pickarg) {
  ------------------
  |  Branch (1182:13): [True: 0, False: 0]
  ------------------
 1183|      0|          if (altmode && mrb_nil_p(*pickarg)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1183:15): [True: 0, False: 0]
  ------------------
 1184|      0|            *datap = NULL;
 1185|      0|          }
 1186|      0|          else {
 1187|      0|            *datap = mrb_data_get_ptr(mrb, *pickarg, type);
 1188|      0|          }
 1189|      0|        }
 1190|      0|      }
 1191|      0|      break;
 1192|       |
 1193|  1.74k|    case '&':
  ------------------
  |  Branch (1193:5): [True: 1.74k, False: 216k]
  ------------------
 1194|  1.74k|      {
 1195|  1.74k|        mrb_value *p, *bp;
 1196|       |
 1197|  1.74k|        p = GET_ARG(mrb_value*);
  ------------------
  |  |  904|  1.74k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 1.74k]
  |  |  ------------------
  ------------------
 1198|  1.74k|        bp = ci->stack + mrb_ci_bidx(ci);
 1199|  1.74k|        if (altmode && mrb_nil_p(*bp)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1199:13): [True: 0, False: 1.74k]
  ------------------
 1200|      0|          mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1201|      0|        }
 1202|  1.74k|        *p = *bp;
 1203|  1.74k|      }
 1204|      0|      break;
 1205|  36.3k|    case '|':
  ------------------
  |  Branch (1205:5): [True: 36.3k, False: 181k]
  ------------------
 1206|  36.3k|      if (opt_skip && i == argc) goto finish;
  ------------------
  |  Branch (1206:11): [True: 34.6k, False: 1.74k]
  |  Branch (1206:23): [True: 25.4k, False: 9.22k]
  ------------------
 1207|  10.9k|      opt = TRUE;
  ------------------
  |  |   54|  10.9k|#  define TRUE 1
  ------------------
 1208|  10.9k|      break;
 1209|      0|    case '?':
  ------------------
  |  Branch (1209:5): [True: 0, False: 218k]
  ------------------
 1210|      0|      {
 1211|      0|        mrb_bool *p;
 1212|       |
 1213|      0|        p = GET_ARG(mrb_bool*);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1214|      0|        *p = pickarg ? TRUE : FALSE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
                      *p = pickarg ? TRUE : FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (1214:14): [True: 0, False: 0]
  ------------------
 1215|      0|      }
 1216|      0|      break;
 1217|       |
 1218|  27.9k|    case '*':
  ------------------
  |  Branch (1218:5): [True: 27.9k, False: 190k]
  ------------------
 1219|  27.9k|      {
 1220|  27.9k|        const mrb_value **var;
 1221|  27.9k|        mrb_int *pl;
 1222|  27.9k|        mrb_bool nocopy = (altmode || !argv_on_stack) ? TRUE : FALSE;
  ------------------
  |  |   54|  17.4k|#  define TRUE 1
  ------------------
                      mrb_bool nocopy = (altmode || !argv_on_stack) ? TRUE : FALSE;
  ------------------
  |  |   51|  38.3k|#  define FALSE 0
  ------------------
  |  Branch (1222:28): [True: 0, False: 27.9k]
  |  Branch (1222:39): [True: 17.4k, False: 10.4k]
  ------------------
 1223|       |
 1224|  27.9k|        var = GET_ARG(const mrb_value**);
  ------------------
  |  |  904|  27.9k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 27.9k]
  |  |  ------------------
  ------------------
 1225|  27.9k|        pl = GET_ARG(mrb_int*);
  ------------------
  |  |  904|  27.9k|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 27.9k]
  |  |  ------------------
  ------------------
 1226|  27.9k|        if (argc > i) {
  ------------------
  |  Branch (1226:13): [True: 27.9k, False: 0]
  ------------------
 1227|  27.9k|          *pl = argc-i;
 1228|  27.9k|          if (*pl > 0) {
  ------------------
  |  Branch (1228:15): [True: 27.9k, False: 0]
  ------------------
 1229|  27.9k|            if (nocopy) {
  ------------------
  |  Branch (1229:17): [True: 17.4k, False: 10.4k]
  ------------------
 1230|  17.4k|              *var = argv+i;
 1231|  17.4k|            }
 1232|  10.4k|            else {
 1233|  10.4k|              mrb_value args = mrb_ary_new_from_values(mrb, *pl, argv+i);
 1234|  10.4k|              RARRAY(args)->c = NULL;
  ------------------
  |  |   53|  10.4k|#define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  10.4k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1235|  10.4k|              *var = RARRAY_PTR(args);
  ------------------
  |  |   73|  10.4k|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|  10.4k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  10.4k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  10.4k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 8.72k, False: 1.74k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|  8.72k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1236|  10.4k|            }
 1237|  27.9k|          }
 1238|  27.9k|          i = argc;
 1239|  27.9k|        }
 1240|      0|        else {
 1241|      0|          *pl = 0;
 1242|      0|          *var = NULL;
 1243|      0|        }
 1244|  27.9k|      }
 1245|  27.9k|      break;
 1246|       |
 1247|      0|    case ':':
  ------------------
  |  Branch (1247:5): [True: 0, False: 218k]
  ------------------
 1248|      0|      {
 1249|      0|        mrb_value ksrc = mrb_hash_p(kdict) ? mrb_hash_dup(mrb, kdict) : mrb_hash_new(mrb);
  ------------------
  |  |  188|      0|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1250|      0|        const mrb_kwargs *kwargs = GET_ARG(const mrb_kwargs*);
  ------------------
  |  |  904|      0|#define GET_ARG(_type) (ptr ? ((_type)(*ptr++)) : va_arg((*ap), _type))
  |  |  ------------------
  |  |  |  Branch (904:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1251|      0|        mrb_value *rest;
 1252|       |
 1253|      0|        if (kwargs == NULL) {
  ------------------
  |  Branch (1253:13): [True: 0, False: 0]
  ------------------
 1254|      0|          rest = NULL;
 1255|      0|        }
 1256|      0|        else {
 1257|      0|          mrb_int kwnum = kwargs->num;
 1258|      0|          mrb_int required = kwargs->required;
 1259|      0|          const mrb_sym *kname = kwargs->table;
 1260|      0|          mrb_value *values = kwargs->values;
 1261|      0|          mrb_int j;
 1262|      0|          const uint32_t keyword_max = 40;
 1263|       |
 1264|      0|          mrb_assert(kwnum >= 0);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1265|      0|          mrb_assert(required >= 0);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1266|      0|          if (kwnum > keyword_max || required > kwnum) {
  ------------------
  |  Branch (1266:15): [True: 0, False: 0]
  |  Branch (1266:38): [True: 0, False: 0]
  ------------------
 1267|      0|            mrb_raise(mrb, E_ARGUMENT_ERROR, "keyword number is too large");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1268|      0|          }
 1269|       |
 1270|      0|          for (j = required; j > 0; j--, kname++, values++) {
  ------------------
  |  Branch (1270:30): [True: 0, False: 0]
  ------------------
 1271|      0|            mrb_value k = mrb_symbol_value(*kname);
 1272|      0|            if (!mrb_hash_key_p(mrb, ksrc, k)) {
  ------------------
  |  Branch (1272:17): [True: 0, False: 0]
  ------------------
 1273|      0|              mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %n", *kname);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1274|      0|            }
 1275|      0|            *values = mrb_hash_delete_key(mrb, ksrc, k);
 1276|      0|            mrb_gc_protect(mrb, *values);
 1277|      0|          }
 1278|       |
 1279|      0|          for (j = kwnum - required; j > 0; j--, kname++, values++) {
  ------------------
  |  Branch (1279:38): [True: 0, False: 0]
  ------------------
 1280|      0|            mrb_value k = mrb_symbol_value(*kname);
 1281|      0|            if (mrb_hash_key_p(mrb, ksrc, k)) {
  ------------------
  |  Branch (1281:17): [True: 0, False: 0]
  ------------------
 1282|      0|              *values = mrb_hash_delete_key(mrb, ksrc, k);
 1283|      0|              mrb_gc_protect(mrb, *values);
 1284|      0|            }
 1285|      0|            else {
 1286|      0|              *values = mrb_undef_value();
 1287|      0|            }
 1288|      0|          }
 1289|       |
 1290|      0|          rest = kwargs->rest;
 1291|      0|        }
 1292|       |
 1293|      0|        if (rest) {
  ------------------
  |  Branch (1293:13): [True: 0, False: 0]
  ------------------
 1294|      0|          *rest = ksrc;
 1295|      0|        }
 1296|      0|        else if (!mrb_hash_empty_p(mrb, ksrc)) {
  ------------------
  |  Branch (1296:18): [True: 0, False: 0]
  ------------------
 1297|      0|          ksrc = mrb_hash_keys(mrb, ksrc);
 1298|      0|          ksrc = RARRAY_PTR(ksrc)[0];
  ------------------
  |  |   73|      0|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1299|      0|          mrb_raisef(mrb, E_ARGUMENT_ERROR, "unknown keyword: %v", ksrc);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1300|      0|        }
 1301|      0|      }
 1302|      0|      break;
 1303|       |
 1304|      0|    default:
  ------------------
  |  Branch (1304:5): [True: 0, False: 218k]
  ------------------
 1305|      0|      mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid argument specifier %c", c);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1306|      0|      break;
 1307|   218k|    }
 1308|   218k|  }
 1309|       |
 1310|   135k|  if (!c && argc > i) {
  ------------------
  |  Branch (1310:7): [True: 135k, False: 0]
  |  Branch (1310:13): [True: 0, False: 135k]
  ------------------
 1311|      0|    mrb_argnum_error(mrb, argc, argc_min, argc_max);
 1312|      0|  }
 1313|       |
 1314|   161k|finish:
 1315|   161k|  return i;
 1316|   135k|}
class.c:ensure_class_type:
  838|  63.5k|{
  839|  63.5k|  if (!class_ptr_p(val)) {
  ------------------
  |  Branch (839:7): [True: 0, False: 63.5k]
  ------------------
  840|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", val);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  841|      0|  }
  842|  63.5k|}
class.c:include_module_at:
 1420|  29.6k|{
 1421|  29.6k|  struct RClass *p, *ic;
 1422|  29.6k|  void *klass_mt = find_origin(c)->mt;
 1423|       |
 1424|  59.3k|  while (m) {
  ------------------
  |  Branch (1424:10): [True: 29.6k, False: 29.6k]
  ------------------
 1425|  29.6k|    int original_seen = FALSE;
  ------------------
  |  |   51|  29.6k|#  define FALSE 0
  ------------------
 1426|  29.6k|    int superclass_seen = FALSE;
  ------------------
  |  |   51|  29.6k|#  define FALSE 0
  ------------------
 1427|       |
 1428|  29.6k|    if (c == ins_pos) original_seen = TRUE;
  ------------------
  |  |   54|  29.6k|#  define TRUE 1
  ------------------
  |  Branch (1428:9): [True: 29.6k, False: 0]
  ------------------
 1429|  29.6k|    if (m->flags & MRB_FL_CLASS_IS_PREPENDED)
  ------------------
  |  |   63|  29.6k|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  ------------------
  |  Branch (1429:9): [True: 0, False: 29.6k]
  ------------------
 1430|      0|      goto skip;
 1431|       |
 1432|  29.6k|    if (klass_mt && klass_mt == m->mt)
  ------------------
  |  Branch (1432:9): [True: 29.6k, False: 0]
  |  Branch (1432:21): [True: 0, False: 29.6k]
  ------------------
 1433|      0|      return -1;
 1434|       |
 1435|  29.6k|    p = c->super;
 1436|   118k|    while (p) {
  ------------------
  |  Branch (1436:12): [True: 88.9k, False: 29.6k]
  ------------------
 1437|  88.9k|      if (c == p) original_seen = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (1437:11): [True: 0, False: 88.9k]
  ------------------
 1438|  88.9k|      if (p->tt == MRB_TT_ICLASS) {
  ------------------
  |  Branch (1438:11): [True: 29.6k, False: 59.3k]
  ------------------
 1439|  29.6k|        if (p->mt == m->mt) {
  ------------------
  |  Branch (1439:13): [True: 0, False: 29.6k]
  ------------------
 1440|      0|          if (!superclass_seen && original_seen) {
  ------------------
  |  Branch (1440:15): [True: 0, False: 0]
  |  Branch (1440:35): [True: 0, False: 0]
  ------------------
 1441|      0|            ins_pos = p; /* move insert point */
 1442|      0|          }
 1443|      0|          goto skip;
 1444|      0|        }
 1445|  29.6k|      }
 1446|  59.3k|      else if (p->tt == MRB_TT_CLASS) {
  ------------------
  |  Branch (1446:16): [True: 59.3k, False: 0]
  ------------------
 1447|  59.3k|        if (!search_super) break;
  ------------------
  |  Branch (1447:13): [True: 0, False: 59.3k]
  ------------------
 1448|  59.3k|        superclass_seen = TRUE;
  ------------------
  |  |   54|  59.3k|#  define TRUE 1
  ------------------
 1449|  59.3k|      }
 1450|  88.9k|      p = p->super;
 1451|  88.9k|    }
 1452|       |
 1453|  29.6k|    ic = include_class_new(mrb, m, ins_pos->super);
 1454|  29.6k|    m->flags |= MRB_FL_CLASS_IS_INHERITED;
  ------------------
  |  |   73|  29.6k|#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
  ------------------
 1455|  29.6k|    ins_pos->super = ic;
 1456|  29.6k|    mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic);
 1457|  29.6k|    ins_pos = ic;
 1458|  29.6k|  skip:
 1459|  29.6k|    m = m->super;
 1460|  29.6k|  }
 1461|  29.6k|  mc_clear(mrb);
 1462|  29.6k|  return 0;
 1463|  29.6k|}
class.c:include_class_new:
 1400|  29.6k|{
 1401|  29.6k|  struct RClass *ic = MRB_OBJ_ALLOC(mrb, MRB_TT_ICLASS, mrb->class_class);
  ------------------
  |  | 1200|  29.6k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 1402|  29.6k|  if (m->tt == MRB_TT_ICLASS) {
  ------------------
  |  Branch (1402:7): [True: 0, False: 29.6k]
  ------------------
 1403|      0|    m = m->c;
 1404|      0|  }
 1405|  29.6k|  MRB_CLASS_ORIGIN(m);
  ------------------
  |  |   65|  29.6k|#define MRB_CLASS_ORIGIN(c) do {\
  |  |   66|  29.6k|  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
  |  |  ------------------
  |  |  |  |   63|  29.6k|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  |  |  ------------------
  |  |  |  Branch (66:7): [True: 0, False: 29.6k]
  |  |  ------------------
  |  |   67|      0|    (c) = (c)->super;\
  |  |   68|      0|    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
  |  |  ------------------
  |  |  |  Branch (68:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|      (c) = (c)->super;\
  |  |   70|      0|    }\
  |  |   71|      0|  }\
  |  |   72|  29.6k|} while (0)
  |  |  ------------------
  |  |  |  Branch (72:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1406|  29.6k|  ic->iv = m->iv;
 1407|  29.6k|  ic->mt = m->mt;
 1408|  29.6k|  ic->super = super;
 1409|  29.6k|  if (m->tt == MRB_TT_ICLASS) {
  ------------------
  |  Branch (1409:7): [True: 0, False: 29.6k]
  ------------------
 1410|      0|    ic->c = m->c;
 1411|      0|  }
 1412|  29.6k|  else {
 1413|  29.6k|    ic->c = m;
 1414|  29.6k|  }
 1415|  29.6k|  return ic;
 1416|  29.6k|}
class.c:mc_clear:
 1736|  29.6k|{
 1737|  29.6k|  static const struct mrb_cache_entry ce_zero ={0};
 1738|       |
 1739|  7.62M|  for (int i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
  ------------------
  |  |  218|  7.62M|# define MRB_METHOD_CACHE_SIZE (1<<8)
  ------------------
  |  Branch (1739:17): [True: 7.59M, False: 29.6k]
  ------------------
 1740|  7.59M|    mrb->cache[i] = ce_zero;
 1741|  7.59M|  }
 1742|  29.6k|}
class.c:find_origin:
  515|  59.3k|{
  516|  59.3k|  MRB_CLASS_ORIGIN(c);
  ------------------
  |  |   65|  59.3k|#define MRB_CLASS_ORIGIN(c) do {\
  |  |   66|  59.3k|  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
  |  |  ------------------
  |  |  |  |   63|  59.3k|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  |  |  ------------------
  |  |  |  Branch (66:7): [True: 0, False: 59.3k]
  |  |  ------------------
  |  |   67|      0|    (c) = (c)->super;\
  |  |   68|      0|    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
  |  |  ------------------
  |  |  |  Branch (68:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|      (c) = (c)->super;\
  |  |   70|      0|    }\
  |  |   71|      0|  }\
  |  |   72|  59.3k|} while (0)
  |  |  ------------------
  |  |  |  Branch (72:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  517|  59.3k|  return c;
  518|  59.3k|}
class.c:prepare_singleton_class:
  366|   521k|{
  367|   521k|  struct RClass *sc, *c;
  368|       |
  369|   521k|  mrb_assert(o->c);
  ------------------
  |  |   68|   521k|#define mrb_assert(p) ((void)0)
  ------------------
  370|   521k|  if (o->c->tt == MRB_TT_SCLASS) return;
  ------------------
  |  Branch (370:7): [True: 364k, False: 157k]
  ------------------
  371|   157k|  sc = MRB_OBJ_ALLOC(mrb, MRB_TT_SCLASS, mrb->class_class);
  ------------------
  |  | 1200|   157k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
  372|   157k|  sc->flags |= MRB_FL_CLASS_IS_INHERITED;
  ------------------
  |  |   73|   157k|#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
  ------------------
  373|   157k|  sc->mt = NULL;
  374|   157k|  sc->iv = NULL;
  375|   157k|  if (o->tt == MRB_TT_CLASS) {
  ------------------
  |  Branch (375:7): [True: 129k, False: 27.9k]
  ------------------
  376|   129k|    c = (struct RClass*)o;
  377|   129k|    if (!c->super) {
  ------------------
  |  Branch (377:9): [True: 1.74k, False: 127k]
  ------------------
  378|  1.74k|      sc->super = mrb->class_class;
  379|  1.74k|    }
  380|   127k|    else {
  381|   127k|      sc->super = c->super->c;
  382|   127k|    }
  383|   129k|  }
  384|  27.9k|  else if (o->tt == MRB_TT_SCLASS) {
  ------------------
  |  Branch (384:12): [True: 13.9k, False: 13.9k]
  ------------------
  385|  13.9k|    c = (struct RClass*)o;
  386|  13.9k|    while (c->super->tt == MRB_TT_ICLASS)
  ------------------
  |  Branch (386:12): [True: 0, False: 13.9k]
  ------------------
  387|      0|      c = c->super;
  388|  13.9k|    make_metaclass(mrb, c->super);
  ------------------
  |  |  362|  13.9k|#define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
  ------------------
  389|  13.9k|    sc->super = c->super->c;
  390|  13.9k|  }
  391|  13.9k|  else {
  392|  13.9k|    sc->super = o->c;
  393|  13.9k|    prepare_singleton_class(mrb, (struct RBasic*)sc);
  394|  13.9k|  }
  395|   157k|  o->c = sc;
  396|   157k|  mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc);
  397|   157k|  mrb_obj_iv_set(mrb, (struct RObject*)sc, MRB_SYM(__attached__), mrb_obj_value(o));
  ------------------
  |  |   18|   157k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  398|   157k|  sc->flags |= o->flags & MRB_FL_OBJ_IS_FROZEN;
  ------------------
  |  |   24|   157k|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  ------------------
  399|   157k|}
class.c:mc_clear_by_id:
 1757|  2.41M|{
 1758|  2.41M|  struct mrb_cache_entry *mc = mrb->cache;
 1759|       |
 1760|   619M|  for (int i=0; i<MRB_METHOD_CACHE_SIZE; mc++,i++) {
  ------------------
  |  |  218|   619M|# define MRB_METHOD_CACHE_SIZE (1<<8)
  ------------------
  |  Branch (1760:17): [True: 617M, False: 2.41M]
  ------------------
 1761|   617M|    if (mc->mid == id) mc->c = NULL;
  ------------------
  |  Branch (1761:9): [True: 25.4k, False: 617M]
  ------------------
 1762|   617M|  }
 1763|  2.41M|}
class.c:mt_get:
  142|  1.05M|{
  143|  1.05M|  int hash, pos, start;
  144|       |
  145|  1.05M|  if (t == NULL) return 0;
  ------------------
  |  Branch (145:7): [True: 0, False: 1.05M]
  ------------------
  146|  1.05M|  if (t->alloc == 0) return 0;
  ------------------
  |  Branch (146:7): [True: 29.7k, False: 1.02M]
  ------------------
  147|  1.02M|  if (t->size == 0) return 0;
  ------------------
  |  Branch (147:7): [True: 0, False: 1.02M]
  ------------------
  148|       |
  149|  1.02M|  mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
  150|  1.02M|  union mt_ptr *vals = t->ptr;
  151|  1.02M|  hash = kh_int_hash_func(mrb, sym);
  ------------------
  |  |  267|  1.02M|#define kh_int_hash_func(mrb,key) (khint_t)((key)^((key)<<2)^((key)>>2))
  ------------------
  152|       |#ifdef MRB_USE_INLINE_METHOD_CACHE
  153|       |  int cpos = (hash^(uintptr_t)t) % MT_INLINE_CACHE_SIZE;
  154|       |  pos = mt_cache[cpos];
  155|       |  if (pos < t->alloc) {
  156|       |    mrb_sym key = keys[pos];
  157|       |    if (key) {
  158|       |      if (MT_KEY_SYM(key) == sym) {
  159|       |        *pp = vals[pos];
  160|       |        return key;
  161|       |      }
  162|       |    }
  163|       |  }
  164|       |#endif
  165|  1.02M|  start = pos = hash & (t->alloc-1);
  166|  2.09M|  for (;;) {
  167|  2.09M|    mrb_sym key = keys[pos];
  168|  2.09M|    if (MT_KEY_SYM(key) == sym) {
  ------------------
  |  |   35|  2.09M|#define MT_KEY_SYM(k) ((k)>>2)
  ------------------
  |  Branch (168:9): [True: 525k, False: 1.56M]
  ------------------
  169|   525k|      *pp = vals[pos];
  170|       |#ifdef MRB_USE_INLINE_METHOD_CACHE
  171|       |      if (pos < 0x100) {
  172|       |        mt_cache[cpos] = pos;
  173|       |      }
  174|       |#endif
  175|   525k|      return key;
  176|   525k|    }
  177|  1.56M|    else if (key == MT_EMPTY) {
  ------------------
  |  |   30|  1.56M|#define MT_EMPTY 0
  ------------------
  |  Branch (177:14): [True: 496k, False: 1.07M]
  ------------------
  178|   496k|      return 0;
  179|   496k|    }
  180|  1.07M|    pos = (pos+1) & (t->alloc-1);
  181|  1.07M|    if (pos == start) {         /* not found */
  ------------------
  |  Branch (181:9): [True: 4.20k, False: 1.06M]
  ------------------
  182|  4.20k|      return 0;
  183|  4.20k|    }
  184|  1.07M|  }
  185|  1.02M|}
class.c:mrb_instance_alloc:
 1929|  44.9k|{
 1930|  44.9k|  struct RClass *c = mrb_class_ptr(cv);
  ------------------
  |  |   24|  44.9k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  44.9k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1931|  44.9k|  struct RObject *o;
 1932|  44.9k|  enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
  ------------------
  |  |   76|  44.9k|#define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
  |  |  ------------------
  |  |  |  |   74|  44.9k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 1933|       |
 1934|  44.9k|  if (c->tt == MRB_TT_SCLASS)
  ------------------
  |  Branch (1934:7): [True: 0, False: 44.9k]
  ------------------
 1935|      0|    mrb_raise(mrb, E_TYPE_ERROR, "can't create instance of singleton class");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1936|       |
 1937|  44.9k|  if (c == mrb->nil_class || c == mrb->false_class) {
  ------------------
  |  Branch (1937:7): [True: 0, False: 44.9k]
  |  Branch (1937:30): [True: 0, False: 44.9k]
  ------------------
 1938|      0|    mrb_assert(ttype == 0);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1939|      0|  }
 1940|  44.9k|  else if (ttype == 0) {
  ------------------
  |  Branch (1940:12): [True: 26.6k, False: 18.3k]
  ------------------
 1941|  26.6k|    ttype = MRB_TT_OBJECT;
 1942|  26.6k|  }
 1943|  44.9k|  if (ttype <= MRB_TT_CPTR) {
  ------------------
  |  Branch (1943:7): [True: 0, False: 44.9k]
  ------------------
 1944|      0|    if (ttype == MRB_TT_UNDEF) {
  ------------------
  |  Branch (1944:9): [True: 0, False: 0]
  ------------------
 1945|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "allocator undefined for %v", cv);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1946|      0|    }
 1947|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "can't create instance of %v", cv);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1948|      0|  }
 1949|  44.9k|  o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
 1950|  44.9k|  return mrb_obj_value(o);
 1951|  44.9k|}
class.c:mrb_do_nothing:
 2052|  24.4k|{
 2053|  24.4k|  return mrb_nil_value();
 2054|  24.4k|}
class.c:class_name_str:
  403|     92|{
  404|     92|  mrb_value path = mrb_class_path(mrb, c);
  405|     92|  if (mrb_nil_p(path)) {
  ------------------
  |  |  174|     92|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 92]
  |  |  ------------------
  ------------------
  406|      0|    path = c->tt == MRB_TT_MODULE ? mrb_str_new_lit(mrb, "#<Module:") :
  ------------------
  |  | 1209|      0|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  |  Branch (406:12): [True: 0, False: 0]
  ------------------
  407|      0|                                    mrb_str_new_lit(mrb, "#<Class:");
  ------------------
  |  | 1209|      0|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  408|      0|    mrb_str_cat_str(mrb, path, mrb_ptr_to_str(mrb, c));
  409|      0|    mrb_str_cat_lit(mrb, path, ">");
  ------------------
  |  |  395|      0|#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  410|      0|  }
  411|     92|  return path;
  412|     92|}
class.c:mrb_check_inheritable:
 2172|   113k|{
 2173|   113k|  if (super->tt != MRB_TT_CLASS) {
  ------------------
  |  Branch (2173:7): [True: 0, False: 113k]
  ------------------
 2174|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%C given)", super);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2175|      0|  }
 2176|   113k|  if (super->tt == MRB_TT_SCLASS) {
  ------------------
  |  Branch (2176:7): [True: 0, False: 113k]
  ------------------
 2177|      0|    mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of singleton class");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2178|      0|  }
 2179|   113k|  if (super == mrb->class_class) {
  ------------------
  |  Branch (2179:7): [True: 0, False: 113k]
  ------------------
 2180|      0|    mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of Class");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2181|      0|  }
 2182|   113k|}
class.c:boot_defclass:
 1374|   129k|{
 1375|   129k|  struct RClass *c;
 1376|       |
 1377|   129k|  c = MRB_OBJ_ALLOC(mrb, MRB_TT_CLASS, mrb->class_class);
  ------------------
  |  | 1200|   129k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
 1378|   129k|  if (super) {
  ------------------
  |  Branch (1378:7): [True: 118k, False: 10.4k]
  ------------------
 1379|   118k|    c->super = super;
 1380|   118k|    mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)super);
 1381|   118k|    c->flags |= MRB_FL_CLASS_IS_INHERITED;
  ------------------
  |  |   73|   118k|#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
  ------------------
 1382|   118k|  }
 1383|  10.4k|  else {
 1384|  10.4k|    c->super = mrb->object_class;
 1385|  10.4k|  }
 1386|   129k|  c->mt = mt_new(mrb);
 1387|   129k|  return c;
 1388|   129k|}
class.c:boot_initmod:
 1392|  17.4k|{
 1393|  17.4k|  if (!mod->mt) {
  ------------------
  |  Branch (1393:7): [True: 17.4k, False: 0]
  ------------------
 1394|  17.4k|    mod->mt = mt_new(mrb);
 1395|  17.4k|  }
 1396|  17.4k|}
class.c:class_ptr_p:
  434|   206k|{
  435|   206k|  switch (mrb_type(obj)) {
  436|   206k|  case MRB_TT_CLASS:
  ------------------
  |  Branch (436:3): [True: 206k, False: 0]
  ------------------
  437|   206k|  case MRB_TT_SCLASS:
  ------------------
  |  Branch (437:3): [True: 0, False: 206k]
  ------------------
  438|   206k|  case MRB_TT_MODULE:
  ------------------
  |  Branch (438:3): [True: 0, False: 206k]
  ------------------
  439|   206k|    return TRUE;
  ------------------
  |  |   54|   206k|#  define TRUE 1
  ------------------
  440|      0|  default:
  ------------------
  |  Branch (440:3): [True: 0, False: 206k]
  ------------------
  441|      0|    return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  442|   206k|  }
  443|   206k|}
class.c:undef_method:
 2329|  31.4k|{
 2330|  31.4k|  mrb_method_t m;
 2331|       |
 2332|  31.4k|  MRB_METHOD_FROM_PROC(m, NULL);
  ------------------
  |  |  112|  31.4k|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
 2333|  31.4k|  mrb_define_method_raw(mrb, c, a, m);
 2334|  31.4k|}
class.c:mrb_bob_not:
 2058|  2.97k|{
 2059|  2.97k|  return mrb_bool_value(!mrb_test(cv));
  ------------------
  |  |  312|  2.97k|#define mrb_test(o)   mrb_bool(o)
  |  |  ------------------
  |  |  |  |  168|  2.97k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  |  |  ------------------
  ------------------
 2060|  2.97k|}
class.c:init_class_new:
 2966|  1.74k|{
 2967|  1.74k|  mrb_method_t m;
 2968|       |
 2969|  1.74k|  MRB_PRESYM_INIT_SYMBOLS(mrb, new_syms);
  ------------------
  |  |   31|  1.74k|#define MRB_PRESYM_INIT_SYMBOLS(mrb, name) (void)(mrb)
  ------------------
 2970|  1.74k|  MRB_METHOD_FROM_PROC(m, &new_proc);
  ------------------
  |  |  112|  1.74k|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
 2971|  1.74k|  mrb_define_method_raw(mrb, cls, MRB_SYM(new), m);
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2972|  1.74k|}
class.c:mrb_mod_append_features:
 1560|  22.6k|{
 1561|  22.6k|  struct RClass *c;
 1562|       |
 1563|  22.6k|  mrb_check_type(mrb, mod, MRB_TT_MODULE);
 1564|  22.6k|  mrb_get_args(mrb, "c", &c);
 1565|  22.6k|  mrb_include_module(mrb, c, mrb_class_ptr(mod));
  ------------------
  |  |   24|  22.6k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  22.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1566|  22.6k|  return mod;
 1567|  22.6k|}
class.c:mrb_mod_dummy_visibility:
 1650|  1.74k|{
 1651|  1.74k|  return mod;
 1652|  1.74k|}
class.c:mrb_mod_attr_reader:
 1907|  19.1k|{
 1908|  19.1k|  return mod_attr_define(mrb, mod, attr_reader, NULL);
 1909|  19.1k|}
class.c:mod_attr_define:
 1870|  27.9k|{
 1871|  27.9k|  struct RClass *c = mrb_class_ptr(mod);
  ------------------
  |  |   24|  27.9k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  27.9k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1872|  27.9k|  const mrb_value *argv;
 1873|  27.9k|  mrb_int argc;
 1874|  27.9k|  int ai;
 1875|       |
 1876|  27.9k|  mrb_get_args(mrb, "*", &argv, &argc);
 1877|  27.9k|  ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  27.9k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
 1878|  71.5k|  for (int i=0; i<argc; i++) {
  ------------------
  |  Branch (1878:17): [True: 43.6k, False: 27.9k]
  ------------------
 1879|  43.6k|    mrb_value name;
 1880|  43.6k|    mrb_sym method;
 1881|  43.6k|    struct RProc *p;
 1882|  43.6k|    mrb_method_t m;
 1883|       |
 1884|  43.6k|    method = to_sym(mrb, argv[i]);
  ------------------
  |  |  844|  43.6k|#define to_sym(mrb, ss) mrb_obj_to_sym(mrb, ss)
  ------------------
 1885|  43.6k|    name = prepare_ivar_name(mrb, method);
 1886|  43.6k|    if (access_name) {
  ------------------
  |  Branch (1886:9): [True: 13.9k, False: 29.6k]
  ------------------
 1887|  13.9k|      method = access_name(mrb, method);
 1888|  13.9k|    }
 1889|       |
 1890|  43.6k|    p = mrb_proc_new_cfunc_with_env(mrb, accessor, 1, &name);
 1891|  43.6k|    MRB_METHOD_FROM_PROC(m, p);
  ------------------
  |  |  112|  43.6k|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
 1892|  43.6k|    mrb_define_method_raw(mrb, c, method, m);
 1893|  43.6k|    mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  43.6k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 1894|  43.6k|  }
 1895|  27.9k|  return mrb_nil_value();
 1896|  27.9k|}
class.c:prepare_ivar_name:
 1856|  43.6k|{
 1857|  43.6k|  sym = prepare_name_common(mrb, sym, "@", NULL);
 1858|  43.6k|  mrb_iv_name_sym_check(mrb, sym);
 1859|  43.6k|  return mrb_symbol_value(sym);
 1860|  43.6k|}
class.c:prepare_name_common:
 1828|  57.5k|{
 1829|  57.5k|  char onstack[ONSTACK_ALLOC_MAX];
 1830|  57.5k|  mrb_int sym_len;
 1831|  57.5k|  const char *sym_str = mrb_sym_name_len(mrb, sym, &sym_len);
 1832|  57.5k|  size_t prefix_len = prefix ? strlen(prefix) : 0;
  ------------------
  |  Branch (1832:23): [True: 43.6k, False: 13.9k]
  ------------------
 1833|  57.5k|  size_t suffix_len = suffix ? strlen(suffix) : 0;
  ------------------
  |  Branch (1833:23): [True: 13.9k, False: 43.6k]
  ------------------
 1834|  57.5k|  size_t name_len = sym_len + prefix_len + suffix_len;
 1835|  57.5k|  char *buf = name_len > sizeof(onstack) ? (char*)mrb_alloca(mrb, name_len) : onstack;
  ------------------
  |  Branch (1835:15): [True: 0, False: 57.5k]
  ------------------
 1836|  57.5k|  char *p = buf;
 1837|       |
 1838|  57.5k|  if (prefix_len > 0) {
  ------------------
  |  Branch (1838:7): [True: 43.6k, False: 13.9k]
  ------------------
 1839|  43.6k|    memcpy(p, prefix, prefix_len);
 1840|  43.6k|    p += prefix_len;
 1841|  43.6k|  }
 1842|       |
 1843|  57.5k|  memcpy(p, sym_str, sym_len);
 1844|  57.5k|  p += sym_len;
 1845|       |
 1846|  57.5k|  if (suffix_len > 0) {
  ------------------
  |  Branch (1846:7): [True: 13.9k, False: 43.6k]
  ------------------
 1847|  13.9k|    memcpy(p, suffix, suffix_len);
 1848|  13.9k|    p += suffix_len;
 1849|  13.9k|  }
 1850|       |
 1851|  57.5k|  return mrb_intern(mrb, buf, name_len);
 1852|  57.5k|}
class.c:mrb_mod_attr_writer:
 1923|  8.72k|{
 1924|  8.72k|  return mod_attr_define(mrb, mod, attr_writer, prepare_writer_name);
 1925|  8.72k|}
class.c:prepare_writer_name:
 1864|  13.9k|{
 1865|  13.9k|  return prepare_name_common(mrb, sym, NULL, "=");
 1866|  13.9k|}
class.c:mrb_mod_alias:
 2317|  17.4k|{
 2318|  17.4k|  struct RClass *c = mrb_class_ptr(mod);
  ------------------
  |  |   24|  17.4k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  17.4k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2319|  17.4k|  mrb_sym new_name, old_name;
 2320|       |
 2321|  17.4k|  mrb_get_args(mrb, "nn", &new_name, &old_name);
 2322|  17.4k|  mrb_alias_method(mrb, c, new_name, old_name);
 2323|  17.4k|  mrb_method_added(mrb, c, new_name);
 2324|  17.4k|  return mod;
 2325|  17.4k|}
class.c:mrb_mod_const_defined:
 2405|  1.74k|{
 2406|  1.74k|  mrb_sym id;
 2407|  1.74k|  mrb_bool inherit = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
 2408|       |
 2409|  1.74k|  mrb_get_args(mrb, "n|b", &id, &inherit);
 2410|  1.74k|  check_const_name_sym(mrb, id);
 2411|  1.74k|  if (inherit) {
  ------------------
  |  Branch (2411:7): [True: 1.74k, False: 0]
  ------------------
 2412|  1.74k|    return mrb_bool_value(mrb_const_defined(mrb, mod, id));
 2413|  1.74k|  }
 2414|      0|  return mrb_bool_value(mrb_const_defined_at(mrb, mod, id));
 2415|  1.74k|}
class.c:check_const_name_sym:
 2395|  1.74k|{
 2396|  1.74k|  mrb_int len;
 2397|  1.74k|  const char *name = mrb_sym_name_len(mrb, id, &len);
 2398|  1.74k|  if (!mrb_const_name_p(mrb, name, len)) {
  ------------------
  |  Branch (2398:7): [True: 0, False: 1.74k]
  ------------------
 2399|      0|    mrb_name_error(mrb, id, "wrong constant name %n", id);
 2400|      0|  }
 2401|  1.74k|}

mrb_init_comparable:
   11|  1.74k|{
   12|  1.74k|  mrb_define_module(mrb, "Comparable");  /* 15.3.3 */
   13|  1.74k|}

mrb_packed_int_len:
   40|   158k|{
   41|   158k|  size_t llen = 0;
   42|       |
   43|   158k|  do {
   44|   158k|    llen++;
   45|   158k|  } while (num >>= 7);
  ------------------
  |  Branch (45:12): [True: 0, False: 158k]
  ------------------
   46|   158k|  return llen;
   47|   158k|}
mrb_packed_int_encode:
   51|   158k|{
   52|   158k|  size_t llen = 0;
   53|       |
   54|   158k|  do {
   55|   158k|    uint8_t byte = num & 0x7f;
   56|   158k|    num >>= 7;
   57|   158k|    if (num != 0) byte |= 0x80;
  ------------------
  |  Branch (57:9): [True: 0, False: 158k]
  ------------------
   58|   158k|    if (p < pend) *p++ = byte;
  ------------------
  |  Branch (58:9): [True: 158k, False: 0]
  ------------------
   59|   158k|    llen++;
   60|   158k|  } while (num != 0);
  ------------------
  |  Branch (60:12): [True: 0, False: 158k]
  ------------------
   61|       |
   62|   158k|  return llen;
   63|   158k|}
mrb_packed_int_decode:
   67|  41.3M|{
   68|  41.3M|  size_t i = 0, shift = 0;
   69|  41.3M|  uint32_t n = 0;
   70|       |
   71|  41.3M|  do {
   72|  41.3M|    n |= ((uint32_t)(p[i] & 0x7f)) << shift;
   73|  41.3M|    i++;
   74|  41.3M|    shift += 7;
   75|  41.3M|  } while (shift < sizeof(uint32_t) * 8 && (p[i - 1] & 0x80));
  ------------------
  |  Branch (75:12): [True: 41.3M, False: 0]
  |  Branch (75:44): [True: 0, False: 41.3M]
  ------------------
   76|  41.3M|  if (newpos) *newpos = p + i;
  ------------------
  |  Branch (76:7): [True: 41.3M, False: 0]
  ------------------
   77|  41.3M|  return n;
   78|  41.3M|}
mrb_debug_get_position:
  161|  3.90k|{
  162|  3.90k|  if (irep && pc < irep->ilen && irep->debug_info) {
  ------------------
  |  Branch (162:7): [True: 3.90k, False: 0]
  |  Branch (162:15): [True: 3.90k, False: 0]
  |  Branch (162:34): [True: 0, False: 3.90k]
  ------------------
  163|      0|    mrb_irep_debug_info_file *f = get_file(irep->debug_info, pc);
  164|      0|    *lp = debug_get_line(mrb, f, pc);
  165|      0|    if (*lp > 0) {
  ------------------
  |  Branch (165:9): [True: 0, False: 0]
  ------------------
  166|      0|      *fp = debug_get_filename(mrb, f);
  167|      0|      if (*fp) return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (167:11): [True: 0, False: 0]
  ------------------
  168|      0|    }
  169|      0|  }
  170|  3.90k|  *lp = -1; *fp = NULL;
  171|  3.90k|  return FALSE;
  ------------------
  |  |   51|  3.90k|#  define FALSE 0
  ------------------
  172|  3.90k|}
mrb_debug_info_free:
  252|  3.46k|{
  253|  3.46k|  uint32_t i;
  254|       |
  255|  3.46k|  if (!d) { return; }
  ------------------
  |  Branch (255:7): [True: 3.46k, False: 0]
  ------------------
  256|       |
  257|      0|  if (d->files) {
  ------------------
  |  Branch (257:7): [True: 0, False: 0]
  ------------------
  258|      0|    for (i = 0; i < d->flen; i++) {
  ------------------
  |  Branch (258:17): [True: 0, False: 0]
  ------------------
  259|      0|      if (d->files[i]) {
  ------------------
  |  Branch (259:11): [True: 0, False: 0]
  ------------------
  260|      0|        mrb_free(mrb, d->files[i]->lines.ptr);
  261|      0|        mrb_free(mrb, d->files[i]);
  262|      0|      }
  263|      0|    }
  264|      0|    mrb_free(mrb, d->files);
  265|      0|  }
  266|      0|  mrb_free(mrb, d);
  267|      0|}

mrb_init_enumerable:
   26|  1.74k|{
   27|  1.74k|  struct RClass *enumerable;
   28|  1.74k|  enumerable = mrb_define_module(mrb, "Enumerable");  /* 15.3.2 */
   29|  1.74k|  mrb_define_module_function(mrb, enumerable, "__update_hash", enum_update_hash, MRB_ARGS_REQ(3));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
   30|  1.74k|}

mrb_exc_mesg_set:
   23|  4.12k|{
   24|  4.12k|  if (!mrb_string_p(mesg)) {
  ------------------
  |  |  187|  4.12k|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|  4.12k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  8.24k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  8.24k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 4.12k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 4.12k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 4.12k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   25|      0|    mesg = mrb_obj_as_string(mrb, mesg);
   26|      0|  }
   27|  4.12k|  exc->mesg = mrb_obj_ptr(mesg);
  ------------------
  |  |   34|  4.12k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  4.12k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   28|  4.12k|  mrb_field_write_barrier_value(mrb, (struct RBasic*)exc, mesg);
  ------------------
  |  | 1317|  4.12k|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|  4.12k|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|  4.12k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  8.24k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 0, False: 4.12k]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 4.12k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|  4.12k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  4.12k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|  4.12k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   29|  4.12k|}
mrb_exc_new_str:
   40|  4.10k|{
   41|  4.10k|  mrb_ensure_string_type(mrb, str);
   42|       |
   43|  4.10k|  struct RException *e = MRB_OBJ_ALLOC(mrb, MRB_TT_EXCEPTION, c);
  ------------------
  |  | 1200|  4.10k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
   44|  4.10k|  mrb_value exc = mrb_obj_value(e);
   45|  4.10k|  mrb_exc_mesg_set(mrb, e, str);
   46|  4.10k|  return exc;
   47|  4.10k|}
mrb_exc_set:
  178|    443|{
  179|    443|  if (mrb_nil_p(exc)) {
  ------------------
  |  |  174|    443|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 443]
  |  |  ------------------
  ------------------
  180|      0|    mrb->exc = 0;
  181|      0|  }
  182|    443|  else {
  183|    443|    mrb->exc = mrb_obj_ptr(exc);
  ------------------
  |  |   34|    443|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|    443|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  184|    443|    if (mrb->gc.arena_idx > 0 &&
  ------------------
  |  Branch (184:9): [True: 443, False: 0]
  ------------------
  185|    443|        (struct RBasic*)mrb->exc == mrb->gc.arena[mrb->gc.arena_idx-1]) {
  ------------------
  |  Branch (185:9): [True: 430, False: 13]
  ------------------
  186|    430|      mrb->gc.arena_idx--;
  187|    430|    }
  188|    443|    if (!mrb->gc.out_of_memory && !mrb_frozen_p(mrb->exc)) {
  ------------------
  |  |   28|    430|#define mrb_frozen_p(o) MRB_FROZEN_P(o)
  |  |  ------------------
  |  |  |  |   25|    430|#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
  |  |  |  |  ------------------
  |  |  |  |  |  |   24|    430|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (188:9): [True: 430, False: 13]
  |  Branch (188:35): [True: 430, False: 0]
  ------------------
  189|    430|      mrb_keep_backtrace(mrb, exc);
  190|    430|    }
  191|    443|  }
  192|    443|}
mrb_exc_raise:
  206|    400|{
  207|    400|  if (mrb_break_p(exc)) {
  ------------------
  |  |  203|    400|#define mrb_break_p(o) WORDBOX_OBJ_TYPE_P(o, BREAK)
  |  |  ------------------
  |  |  |  |   78|    400|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|    800|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|    800|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 400]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 400]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 400]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  208|      0|    mrb->exc = mrb_obj_ptr(exc);
  ------------------
  |  |   34|      0|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  209|      0|  }
  210|    400|  else {
  211|    400|    if (mrb_type(exc) != MRB_TT_EXCEPTION) {
  ------------------
  |  Branch (211:9): [True: 0, False: 400]
  ------------------
  212|      0|      mrb_raise(mrb, E_TYPE_ERROR, "exception object expected");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|      0|    }
  214|    400|    mrb_exc_set(mrb, exc);
  215|    400|  }
  216|    400|  exc_throw(mrb, exc);
  217|    400|}
mrb_raise:
  221|    102|{
  222|    102|  mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mrb_str_new_cstr(mrb, msg)));
  223|    102|}
mrb_vformat:
  265|    307|{
  266|    307|  const char *chars, *p = format, *b = format, *e;
  267|    307|  char ch;
  268|    307|  size_t len;
  269|    307|  mrb_int i;
  270|    307|  struct RClass *cls;
  271|    307|  mrb_bool inspect = FALSE;
  ------------------
  |  |   51|    307|#  define FALSE 0
  ------------------
  272|    307|  mrb_value result = mrb_str_new_capa(mrb, 128), obj, str;
  273|    307|  int ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|    307|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  274|       |
  275|  9.02k|  while (*p) {
  ------------------
  |  Branch (275:10): [True: 8.71k, False: 307]
  ------------------
  276|  8.71k|    const char c = *p++;
  277|  8.71k|    e = p;
  278|  8.71k|    if (c == '%') {
  ------------------
  |  Branch (278:9): [True: 405, False: 8.31k]
  ------------------
  279|    405|      if (*p == '!') {
  ------------------
  |  Branch (279:11): [True: 0, False: 405]
  ------------------
  280|      0|        inspect = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  281|      0|        p++;
  282|      0|      }
  283|    405|      if (!*p) break;
  ------------------
  |  Branch (283:11): [True: 0, False: 405]
  ------------------
  284|    405|      switch (*p) {
  285|      0|        case 'c':
  ------------------
  |  Branch (285:9): [True: 0, False: 405]
  ------------------
  286|      0|          ch = (char)va_arg(ap, int);
  287|      0|          chars = &ch;
  288|      0|          len = 1;
  289|      0|          goto L_cat;
  290|    104|        case 'd': case 'i':
  ------------------
  |  Branch (290:9): [True: 9, False: 396]
  |  Branch (290:19): [True: 95, False: 310]
  ------------------
  291|       |#if MRB_INT_MAX < INT_MAX
  292|       |          i = (mrb_int)va_arg(ap, int);
  293|       |#else
  294|    104|          i = *p == 'd' ? (mrb_int)va_arg(ap, int) : va_arg(ap, mrb_int);
  ------------------
  |  Branch (294:15): [True: 9, False: 95]
  ------------------
  295|    104|#endif
  296|    104|          obj = mrb_int_value(mrb, i);
  297|    104|          goto L_cat_obj;
  298|      0|#ifndef MRB_NO_FLOAT
  299|      3|        case 'f':
  ------------------
  |  Branch (299:9): [True: 3, False: 402]
  ------------------
  300|      3|          obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double));
  301|      3|          goto L_cat_obj;
  302|      0|#endif
  303|      0|        case 'l':
  ------------------
  |  Branch (303:9): [True: 0, False: 405]
  ------------------
  304|      0|          chars = va_arg(ap, char*);
  305|      0|          len = va_arg(ap, size_t);
  306|      6|        L_cat:
  307|      6|          if (inspect) {
  ------------------
  |  Branch (307:15): [True: 0, False: 6]
  ------------------
  308|      0|            obj = mrb_str_new(mrb, chars, len);
  309|      0|            goto L_cat_obj;
  310|      0|          }
  311|    405|        L_cat_plain:
  312|    405|          mrb_str_cat(mrb, result, b,  e - b - 1);
  313|    405|          mrb_str_cat(mrb, result, chars, len);
  314|    405|          b = ++p;
  315|    405|          mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|    405|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  316|    405|          break;
  317|    126|        case 'n':
  ------------------
  |  Branch (317:9): [True: 126, False: 279]
  ------------------
  318|       |#if UINT32_MAX < INT_MAX
  319|       |          obj = mrb_symbol_value((mrb_sym)va_arg(ap, int));
  320|       |#else
  321|    126|          obj = mrb_symbol_value(va_arg(ap, mrb_sym));
  322|    126|#endif
  323|    126|          goto L_cat_obj;
  324|      6|        case 's':
  ------------------
  |  Branch (324:9): [True: 6, False: 399]
  ------------------
  325|      6|          chars = va_arg(ap, char*);
  326|      6|          len = strlen(chars);
  327|      6|          goto L_cat;
  328|     92|        case 't':
  ------------------
  |  Branch (328:9): [True: 92, False: 313]
  ------------------
  329|     92|          cls = mrb_class(mrb, va_arg(ap, mrb_value));
  330|     92|          goto L_cat_class;
  331|      2|        case 'v': case 'S':
  ------------------
  |  Branch (331:9): [True: 2, False: 403]
  |  Branch (331:19): [True: 0, False: 405]
  ------------------
  332|      2|          obj = va_arg(ap, mrb_value);
  333|    399|        L_cat_obj:
  334|    399|          str = (inspect ? mrb_inspect : mrb_obj_as_string)(mrb, obj);
  ------------------
  |  Branch (334:18): [True: 72, False: 327]
  ------------------
  335|    399|          if (mrb_type(str) != MRB_TT_STRING) {
  ------------------
  |  Branch (335:15): [True: 0, False: 399]
  ------------------
  336|      0|            chars = "void (no string conversion)";
  337|      0|            len = strlen(chars);
  338|      0|          }
  339|    399|          else {
  340|    399|            chars = RSTRING_PTR(str);
  ------------------
  |  |  100|    399|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|    399|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|    399|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|    399|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|    398|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 398, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  341|    399|            len = RSTRING_LEN(str);
  ------------------
  |  |  102|    399|#define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
  |  |  ------------------
  |  |  |  |   66|    399|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|    399|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|    399|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    398|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|    398|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  113|    398|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  112|    398|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|    398|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:22): [True: 398, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  342|    399|          }
  343|    399|          goto L_cat_plain;
  344|      0|        case 'C':
  ------------------
  |  Branch (344:9): [True: 0, False: 405]
  ------------------
  345|      0|          cls = va_arg(ap, struct RClass*);
  346|     92|        L_cat_class:
  347|     92|          obj = mrb_obj_value(cls);
  348|     92|          goto L_cat_obj;
  349|      0|        case 'T':
  ------------------
  |  Branch (349:9): [True: 0, False: 405]
  ------------------
  350|      0|          obj = va_arg(ap, mrb_value);
  351|      0|        L_cat_real_class_of:
  352|      0|          cls = mrb_obj_class(mrb, obj);
  353|      0|          goto L_cat_class;
  354|     72|        case 'Y':
  ------------------
  |  Branch (354:9): [True: 72, False: 333]
  ------------------
  355|     72|          obj = va_arg(ap, mrb_value);
  356|     72|          if (!mrb_test(obj) || mrb_true_p(obj)) {
  ------------------
  |  |  312|     72|#define mrb_test(o)   mrb_bool(o)
  |  |  ------------------
  |  |  |  |  168|    144|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  |  |  ------------------
  ------------------
                        if (!mrb_test(obj) || mrb_true_p(obj)) {
  ------------------
  |  |  176|     41|#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
  |  |  ------------------
  |  |  |  Branch (176:24): [True: 41, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (356:15): [True: 31, False: 41]
  ------------------
  357|     72|            inspect = TRUE;
  ------------------
  |  |   54|     72|#  define TRUE 1
  ------------------
  358|     72|            goto L_cat_obj;
  359|     72|          }
  360|      0|          else {
  361|      0|            goto L_cat_real_class_of;
  362|      0|          }
  363|      0|        case '%':
  ------------------
  |  Branch (363:9): [True: 0, False: 405]
  ------------------
  364|      0|        L_cat_current:
  365|      0|          chars = p;
  366|      0|          len = 1;
  367|      0|          goto L_cat_plain;
  368|      0|        default:
  ------------------
  |  Branch (368:9): [True: 0, False: 405]
  ------------------
  369|      0|          mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  370|    405|      }
  371|    405|    }
  372|  8.31k|    else if (c == '\\') {
  ------------------
  |  Branch (372:14): [True: 0, False: 8.31k]
  ------------------
  373|      0|      if (!*p) break;
  ------------------
  |  Branch (373:11): [True: 0, False: 0]
  ------------------
  374|      0|      goto L_cat_current;
  375|       |
  376|      0|    }
  377|  8.71k|  }
  378|       |
  379|    307|  mrb_str_cat(mrb, result, b, p - b);
  380|    307|  return result;
  381|    307|}
mrb_format:
  385|     43|{
  386|     43|  va_list ap;
  387|     43|  mrb_value str;
  388|       |
  389|     43|  va_start(ap, format);
  390|     43|  str = mrb_vformat(mrb, format, ap);
  391|     43|  va_end(ap);
  392|       |
  393|     43|  return str;
  394|     43|}
mrb_raisef:
  405|    138|{
  406|    138|  va_list ap;
  407|    138|  mrb_value exc;
  408|       |
  409|    138|  va_start(ap, fmt);
  410|    138|  exc = error_va(mrb, c, fmt, ap);
  411|    138|  va_end(ap);
  412|       |
  413|    138|  mrb_exc_raise(mrb, exc);
  414|    138|}
mrb_make_exception:
  463|     21|{
  464|     21|  mrb_int n = 1;
  465|       |
  466|     21|  if (mrb_nil_p(mesg)) {
  ------------------
  |  |  174|     21|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 21]
  |  |  ------------------
  ------------------
  467|      0|    n = 0;
  468|      0|  }
  469|     21|  if (mrb_class_p(exc)) {
  ------------------
  |  |  193|     21|#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS)
  |  |  ------------------
  |  |  |  |   78|     21|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|     42|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|     42|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 21]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 21]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 21, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  470|     21|    exc = mrb_funcall_argv(mrb, exc, MRB_SYM(new), n, &mesg);
  ------------------
  |  |   18|     21|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  471|     21|  }
  472|      0|  else if (mrb_exception_p(exc)) {
  ------------------
  |  |  190|      0|#define mrb_exception_p(o) WORDBOX_OBJ_TYPE_P(o, EXCEPTION)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  473|      0|    if (n > 0) {
  ------------------
  |  Branch (473:9): [True: 0, False: 0]
  ------------------
  474|      0|      exc = mrb_obj_clone(mrb, exc);
  475|      0|      mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg);
  ------------------
  |  |   32|      0|#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  476|      0|    }
  477|      0|  }
  478|      0|  else {
  479|      0|    mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  480|      0|  }
  481|     21|  if (mrb_type(exc) != MRB_TT_EXCEPTION) {
  ------------------
  |  Branch (481:7): [True: 0, False: 21]
  ------------------
  482|      0|    mrb_raise(mrb, E_EXCEPTION, "exception object expected");
  ------------------
  |  | 1372|      0|#define E_EXCEPTION          mrb->eException_class
  ------------------
  483|      0|  }
  484|     21|  return exc;
  485|     21|}
mrb_no_method_error:
  509|    126|{
  510|    126|  va_list ap;
  511|    126|  mrb_value exc;
  512|       |
  513|    126|  va_start(ap, fmt);
  514|    126|  exc = error_va(mrb, E_NOMETHOD_ERROR, fmt, ap);
  ------------------
  |  | 1381|    126|#define E_NOMETHOD_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(NoMethodError))
  |  |  ------------------
  |  |  |  |   35|    126|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|    126|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  515|    126|  va_end(ap);
  516|    126|  mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id));
  ------------------
  |  |   14|    126|#define MRB_IVSYM(name) MRB_IVSYM__##name
  ------------------
  517|    126|  mrb_iv_set(mrb, exc, MRB_IVSYM(args), args);
  ------------------
  |  |   14|    126|#define MRB_IVSYM(name) MRB_IVSYM__##name
  ------------------
  518|    126|  mrb_exc_raise(mrb, exc);
  519|    126|}
mrb_check_frozen:
  535|  4.18M|{
  536|  4.18M|  if (mrb_frozen_p((struct RBasic*)o)) {
  ------------------
  |  |   28|  4.18M|#define mrb_frozen_p(o) MRB_FROZEN_P(o)
  |  |  ------------------
  |  |  |  |   25|  4.18M|#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
  |  |  |  |  ------------------
  |  |  |  |  |  |   24|  4.18M|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (25:25): [True: 0, False: 4.18M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  537|      0|    mrb_frozen_error(mrb, o);
  538|      0|  }
  539|  4.18M|}
mrb_argnum_error:
  551|      9|{
  552|      9|#define FMT(exp) "wrong number of arguments (given %i, expected " exp ")"
  553|      9|  if (min == max)
  ------------------
  |  Branch (553:7): [True: 9, False: 0]
  ------------------
  554|      9|    mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d"), argc, min);
  ------------------
  |  | 1377|      9|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      9|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      9|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d"), argc, min);
  ------------------
  |  |  552|      9|#define FMT(exp) "wrong number of arguments (given %i, expected " exp ")"
  ------------------
  555|      0|  else if (max < 0)
  ------------------
  |  Branch (555:12): [True: 0, False: 0]
  ------------------
  556|      0|    mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d+"), argc, min);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d+"), argc, min);
  ------------------
  |  |  552|      0|#define FMT(exp) "wrong number of arguments (given %i, expected " exp ")"
  ------------------
  557|      0|  else
  558|      0|    mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d..%d"), argc, min, max);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d..%d"), argc, min, max);
  ------------------
  |  |  552|      0|#define FMT(exp) "wrong number of arguments (given %i, expected " exp ")"
  ------------------
  559|      9|#undef FMT
  560|      9|}
mrb_core_init_protect:
  566|  3.49k|{
  567|  3.49k|  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
  568|  3.49k|  struct mrb_jmpbuf c_jmp;
  569|  3.49k|  int err = 1;
  570|       |
  571|  3.49k|  MRB_TRY(&c_jmp) {
  ------------------
  |  |   44|  3.49k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  3.49k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 3.49k, False: 0]
  |  |  ------------------
  ------------------
  572|  3.49k|    mrb->jmp = &c_jmp;
  573|  3.49k|    body(mrb, opaque);
  574|  3.49k|    err = 0;
  575|  3.49k|  } MRB_CATCH(&c_jmp) {
  ------------------
  |  |   45|  3.49k|#define MRB_CATCH(buf) } else {
  ------------------
  576|      0|    if (mrb->exc) {
  ------------------
  |  Branch (576:9): [True: 0, False: 0]
  ------------------
  577|      0|      mrb_print_error(mrb);
  578|      0|      mrb->exc = NULL;
  579|      0|    }
  580|      0|    else {
  581|      0|      mrb_core_init_printabort();
  582|      0|    }
  583|      0|  } MRB_END_EXC(&c_jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
  584|       |
  585|  3.49k|  mrb->jmp = prev_jmp;
  586|       |
  587|  3.49k|  return err;
  588|  3.49k|}
mrb_protect_atexit:
  599|  1.74k|{
  600|  1.74k|  if (mrb->atexit_stack_len > 0) {
  ------------------
  |  Branch (600:7): [True: 1.74k, False: 0]
  ------------------
  601|  1.74k|    struct mrb_jmpbuf *prev_jmp = mrb->jmp;
  602|  1.74k|    struct mrb_jmpbuf c_jmp;
  603|  3.49k|    for (int i = mrb->atexit_stack_len; i > 0; --i) {
  ------------------
  |  Branch (603:41): [True: 1.74k, False: 1.74k]
  ------------------
  604|  1.74k|      MRB_TRY(&c_jmp) {
  ------------------
  |  |   44|  1.74k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  1.74k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 1.74k, False: 0]
  |  |  ------------------
  ------------------
  605|  1.74k|        mrb->jmp = &c_jmp;
  606|  1.74k|        mrb->atexit_stack[i - 1](mrb);
  607|  1.74k|        mrb->jmp = prev_jmp;
  608|  1.74k|      } MRB_CATCH(&c_jmp) {
  ------------------
  |  |   45|  1.74k|#define MRB_CATCH(buf) } else {
  ------------------
  609|       |        /* ignore atexit errors */
  610|      0|      } MRB_END_EXC(&c_jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
  611|  1.74k|    }
  612|  1.74k|#ifndef MRB_FIXED_STATE_ATEXIT_STACK
  613|  1.74k|    mrb_free(mrb, mrb->atexit_stack);
  614|  1.74k|#endif
  615|  1.74k|    mrb->jmp = prev_jmp;
  616|  1.74k|  }
  617|  1.74k|}
mrb_raise_nomemory:
  621|     13|{
  622|     13|  if (mrb->nomem_err) {
  ------------------
  |  Branch (622:7): [True: 13, False: 0]
  ------------------
  623|     13|    mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
  624|     13|  }
  625|      0|  else {
  626|      0|    mrb_core_init_abort(mrb);
  627|      0|  }
  628|     13|}
mrb_init_exception:
  670|  1.74k|{
  671|  1.74k|  struct RClass *exception, *script_error, *stack_error, *nomem_error;
  672|       |
  673|  1.74k|  mrb->eException_class = exception = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */
  674|  1.74k|  MRB_SET_INSTANCE_TT(exception, MRB_TT_EXCEPTION);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  675|  1.74k|  mrb_define_class_method(mrb, exception, "exception", mrb_instance_new,  MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  676|  1.74k|  mrb_define_method(mrb, exception, "exception",       exc_exception,     MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  677|  1.74k|  mrb_define_method(mrb, exception, "initialize",      exc_initialize,    MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  678|  1.74k|  mrb_define_method(mrb, exception, "to_s",            exc_to_s,          MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  679|  1.74k|  mrb_define_method(mrb, exception, "inspect",         mrb_exc_inspect,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  680|  1.74k|  mrb_define_method(mrb, exception, "backtrace",       mrb_exc_backtrace, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  681|  1.74k|  mrb_define_method(mrb, exception, "set_backtrace",   exc_set_backtrace, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  682|       |
  683|  1.74k|  mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */
  684|  1.74k|  mrb_define_class(mrb, "RuntimeError", E_STANDARD_ERROR);          /* 15.2.28 */
  ------------------
  |  | 1373|  1.74k|#define E_STANDARD_ERROR     mrb->eStandardError_class
  ------------------
  685|  1.74k|  script_error = mrb_define_class(mrb, "ScriptError", exception);                /* 15.2.37 */
  686|  1.74k|  mrb_define_class(mrb, "SyntaxError", script_error);                                        /* 15.2.38 */
  687|  1.74k|  stack_error = mrb_define_class(mrb, "SystemStackError", exception);
  688|  1.74k|  mrb->stack_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, stack_error, "stack level too deep"));
  ------------------
  |  |   34|  1.74k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  1.74k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  689|       |
  690|  1.74k|  nomem_error = mrb_define_class(mrb, "NoMemoryError", exception);
  691|  1.74k|  mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "Out of memory"));
  ------------------
  |  |   34|  1.74k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  1.74k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  692|       |#ifdef MRB_GC_FIXED_ARENA
  693|       |  mrb->arena_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "arena overflow error"));
  694|       |#endif
  695|  1.74k|}
error.c:exc_throw:
  196|    400|{
  197|    400|  if (!mrb->jmp) {
  ------------------
  |  Branch (197:7): [True: 0, False: 400]
  ------------------
  198|      0|    mrb_print_error(mrb);
  199|      0|    abort();
  200|      0|  }
  201|    400|  MRB_THROW(mrb->jmp);
  ------------------
  |  |   48|    400|#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
  |  |  ------------------
  |  |  |  |   41|    800|#define MRB_LONGJMP longjmp
  |  |  ------------------
  ------------------
  202|      0|}
error.c:error_va:
  398|    264|{
  399|    264|  mrb_value mesg = mrb_vformat(mrb, fmt, ap);
  400|    264|  return mrb_exc_new_str(mrb, c, mesg);
  401|    264|}
error.c:exc_initialize:
   65|     21|{
   66|     21|  mrb_value mesg;
   67|       |
   68|     21|  if (mrb_get_args(mrb, "|o", &mesg) == 1) {
  ------------------
  |  Branch (68:7): [True: 21, False: 0]
  ------------------
   69|     21|    mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg);
  ------------------
  |  |   32|     21|#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
  |  |  ------------------
  |  |  |  |  150|     21|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
   70|     21|  }
   71|     21|  return exc;
   72|     21|}

mrb_data_object_alloc:
   16|  7.97k|{
   17|  7.97k|  struct RData *data;
   18|       |
   19|  7.97k|  data = MRB_OBJ_ALLOC(mrb, MRB_TT_CDATA, klass);
  ------------------
  |  | 1200|  7.97k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
   20|  7.97k|  data->data = ptr;
   21|  7.97k|  data->type = type;
   22|       |
   23|  7.97k|  return data;
   24|  7.97k|}
mrb_obj_to_sym:
   67|  80.2k|{
   68|  80.2k|  if (mrb_symbol_p(name)) return mrb_symbol(name);
  ------------------
  |  |  172|  80.2k|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  80.2k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 80.2k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (mrb_symbol_p(name)) return mrb_symbol(name);
  ------------------
  |  |  167|  80.2k|#define mrb_symbol(o)  (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT)
  |  |  ------------------
  |  |  |  |   63|  80.2k|#define WORDBOX_SYMBOL_SHIFT    32
  |  |  ------------------
  ------------------
   69|      0|  if (mrb_string_p(name)) return mrb_intern_str(mrb, name);
  ------------------
  |  |  187|      0|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   70|      0|  mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a symbol nor a string", name);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  | 1371|      0|#define MRB_ERROR_SYM(sym) mrb_intern_lit(mrb, #sym)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1164|      0|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   71|      0|  return 0;  /* not reached */
   72|      0|}
mrb_word_boxing_float_value:
  152|  35.7k|{
  153|  35.7k|  union mrb_value_ v;
  154|       |
  155|       |#ifdef MRB_WORDBOX_NO_FLOAT_TRUNCATE
  156|       |  v.p = mrb_obj_alloc(mrb, MRB_TT_FLOAT, mrb->float_class);
  157|       |  v.fp->f = f;
  158|       |  MRB_SET_FROZEN_FLAG(v.bp);
  159|       |#elif defined(MRB_64BIT) && defined(MRB_USE_FLOAT32)
  160|       |  v.w = 0;
  161|       |  v.f = f;
  162|       |  v.w = (v.w<<2) | 2;
  163|       |#else
  164|  35.7k|  v.f = f;
  165|  35.7k|  v.w = (v.w & ~3) | 2;
  166|  35.7k|#endif
  167|  35.7k|  return v.value;
  168|  35.7k|}
mrb_word_boxing_value_float:
  174|  30.5k|{
  175|  30.5k|  union mrb_value_ u;
  176|  30.5k|  u.value = v;
  177|       |#if defined(MRB_64BIT) && defined(MRB_USE_FLOAT32)
  178|       |  u.w >>= 2;
  179|       |#else
  180|  30.5k|  u.w &= ~3;
  181|  30.5k|#endif
  182|  30.5k|  return u.f;
  183|  30.5k|}
mrb_boxing_int_value:
  202|   403k|{
  203|   403k|  if (FIXABLE(n)) return mrb_fixnum_value(n);
  ------------------
  |  |   24|   403k|#define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
  |  |  ------------------
  |  |  |  |   21|   403k|#define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
  |  |  |  |  ------------------
  |  |  |  |  |  |   19|   807k|#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   42|   403k|# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   36|   403k|#define MRB_FIXNUM_SHIFT        WORDBOX_FIXNUM_SHIFT
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|   403k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   48|   403k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (19:31): [True: 401k, False: 2.29k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|   401k|#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   41|   401k|# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   36|   401k|#define MRB_FIXNUM_SHIFT        WORDBOX_FIXNUM_SHIFT
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|   401k|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   48|   401k|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (20:31): [True: 398k, False: 3.18k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  204|  5.48k|  else {
  205|  5.48k|    mrb_value v;
  206|  5.48k|    struct RInteger *p;
  207|       |
  208|  5.48k|    p = (struct RInteger*)mrb_obj_alloc(mrb, MRB_TT_INTEGER, mrb->integer_class);
  209|  5.48k|    p->i = n;
  210|  5.48k|    MRB_SET_FROZEN_FLAG((struct RBasic*)p);
  ------------------
  |  |   26|  5.48k|#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
  |  |  ------------------
  |  |  |  |   24|  5.48k|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  ------------------
  ------------------
  211|  5.48k|    SET_OBJ_VALUE(v, p);
  ------------------
  |  |  217|  5.48k|#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
  ------------------
  212|  5.48k|    return v;
  213|  5.48k|  }
  214|   403k|}

mrb_format_float:
   79|      1|mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign) {
   80|      1|  char *s = buf;
   81|      1|  int buf_remaining = (int)buf_size - 1;
   82|      1|  int alt_form = 0;
   83|       |
   84|      1|  if ((uint8_t)fmt & 0x80) {
  ------------------
  |  Branch (84:7): [True: 0, False: 1]
  ------------------
   85|      0|    fmt &= 0x7f;  /* turn off alt_form flag */
   86|      0|    alt_form = 1;
   87|      0|  }
   88|      1|  if (buf_size <= FLT_MIN_BUF_SIZE) {
  ------------------
  |  |   51|      1|#define FLT_MIN_BUF_SIZE  7 // -9e+199
  ------------------
  |  Branch (88:7): [True: 0, False: 1]
  ------------------
   89|       |    // Smallest exp notion is -9e+99 (-9e+199) which is 6 (7) chars plus terminating
   90|       |    // null.
   91|       |
   92|      0|    if (buf_size >= 2) {
  ------------------
  |  Branch (92:9): [True: 0, False: 0]
  ------------------
   93|      0|      *s++ = '?';
   94|      0|    }
   95|      0|    if (buf_size >= 1) {
  ------------------
  |  Branch (95:9): [True: 0, False: 0]
  ------------------
   96|      0|      *s++ = '\0';
   97|      0|    }
   98|      0|    return buf_size >= 2;
   99|      0|  }
  100|      1|  if (signbit(f)) {
  101|      1|    *s++ = '-';
  102|      1|    f = -f;
  103|      1|  }
  104|      0|  else if (sign) {
  ------------------
  |  Branch (104:12): [True: 0, False: 0]
  ------------------
  105|      0|    *s++ = sign;
  106|      0|  }
  107|      1|  buf_remaining -= (int)(s - buf); // Adjust for sign
  108|       |
  109|      1|  {
  110|      1|    char uc = fmt & 0x20;
  111|      1|    if (isinf(f)) {
  112|      0|      *s++ = 'I' ^ uc;
  113|      0|      *s++ = 'N' ^ uc;
  114|      0|      *s++ = 'F' ^ uc;
  115|      0|      goto ret;
  116|      0|    }
  117|      1|    else if (isnan(f)) {
  118|      0|      *s++ = 'N' ^ uc;
  119|      0|      *s++ = 'A' ^ uc;
  120|      0|      *s++ = 'N' ^ uc;
  121|      0|    ret:
  122|      0|      *s = '\0';
  123|      0|      return (int)(s - buf);
  124|      0|    }
  125|      1|  }
  126|       |
  127|      1|  if (prec < 0) {
  ------------------
  |  Branch (127:7): [True: 0, False: 1]
  ------------------
  128|      0|    prec = 6;
  129|      0|  }
  130|      1|  char e_char = 'E' | (fmt & 0x20);   // e_char will match case of fmt
  131|      1|  fmt |= 0x20; // Force fmt to be lowercase
  132|      1|  char org_fmt = fmt;
  133|      1|  if (fmt == 'g' && prec == 0) {
  ------------------
  |  Branch (133:7): [True: 1, False: 0]
  |  Branch (133:21): [True: 0, False: 1]
  ------------------
  134|      0|    prec = 1;
  135|      0|  }
  136|      1|  int e, e1;
  137|      1|  int dec = 0;
  138|      1|  char e_sign = '\0';
  139|      1|  int num_digits = 0;
  140|      1|  const mrb_float *pos_pow = g_pos_pow;
  141|      1|  const mrb_float *neg_pow = g_neg_pow;
  142|       |
  143|      1|  if (f == 0.0) {
  ------------------
  |  Branch (143:7): [True: 0, False: 1]
  ------------------
  144|      0|    e = 0;
  145|      0|    if (fmt == 'e') {
  ------------------
  |  Branch (145:9): [True: 0, False: 0]
  ------------------
  146|      0|      e_sign = '+';
  147|      0|    }
  148|      0|    else if (fmt == 'f') {
  ------------------
  |  Branch (148:14): [True: 0, False: 0]
  ------------------
  149|      0|      num_digits = prec + 1;
  150|      0|    }
  151|      0|  }
  152|      1|  else if (f < 1.0) { // f < 1.0
  ------------------
  |  Branch (152:12): [True: 0, False: 1]
  ------------------
  153|      0|    char first_dig = '0';
  154|      0|    if (f >= FLT_ROUND_TO_ONE) {
  ------------------
  |  |   50|      0|#define FLT_ROUND_TO_ONE 0.999999999995
  ------------------
  |  Branch (154:9): [True: 0, False: 0]
  ------------------
  155|      0|      first_dig = '1';
  156|      0|    }
  157|       |
  158|       |    // Build negative exponent
  159|      0|    for (e = 0, e1 = FLT_DECEXP; e1; e1 >>= 1, pos_pow++, neg_pow++) {
  ------------------
  |  |   49|      0|#define FLT_DECEXP      256
  ------------------
  |  Branch (159:34): [True: 0, False: 0]
  ------------------
  160|      0|      if (*neg_pow > f) {
  ------------------
  |  Branch (160:11): [True: 0, False: 0]
  ------------------
  161|      0|        e += e1;
  162|      0|        f *= *pos_pow;
  163|      0|      }
  164|      0|    }
  165|      0|    char e_sign_char = '-';
  166|      0|    if (f < 1.0) {
  ------------------
  |  Branch (166:9): [True: 0, False: 0]
  ------------------
  167|      0|      if (f >= FLT_ROUND_TO_ONE) {
  ------------------
  |  |   50|      0|#define FLT_ROUND_TO_ONE 0.999999999995
  ------------------
  |  Branch (167:11): [True: 0, False: 0]
  ------------------
  168|      0|        f = 1.0;
  169|      0|        if (e == 0) {
  ------------------
  |  Branch (169:13): [True: 0, False: 0]
  ------------------
  170|      0|          e_sign_char = '+';
  171|      0|        }
  172|      0|      }
  173|      0|      else {
  174|      0|        e++;
  175|      0|        f *= 10.0;
  176|      0|      }
  177|      0|    }
  178|       |
  179|       |    // If the user specified 'g' format, and e is <= 4, then we'll switch
  180|       |    // to the fixed format ('f')
  181|       |
  182|      0|    if (fmt == 'f' || (fmt == 'g' && e <= 4)) {
  ------------------
  |  Branch (182:9): [True: 0, False: 0]
  |  Branch (182:24): [True: 0, False: 0]
  |  Branch (182:38): [True: 0, False: 0]
  ------------------
  183|      0|      fmt = 'f';
  184|      0|      dec = -1;
  185|      0|      *s++ = first_dig;
  186|       |
  187|      0|      if (org_fmt == 'g') {
  ------------------
  |  Branch (187:11): [True: 0, False: 0]
  ------------------
  188|      0|        prec += (e - 1);
  189|      0|      }
  190|       |      // truncate precision to prevent buffer overflow
  191|      0|      if (prec + 2 > buf_remaining) {
  ------------------
  |  Branch (191:11): [True: 0, False: 0]
  ------------------
  192|      0|        prec = buf_remaining - 2;
  193|      0|      }
  194|      0|      num_digits = prec;
  195|      0|      if (num_digits || alt_form) {
  ------------------
  |  Branch (195:11): [True: 0, False: 0]
  |  Branch (195:25): [True: 0, False: 0]
  ------------------
  196|      0|        *s++ = '.';
  197|      0|        while (--e && num_digits) {
  ------------------
  |  Branch (197:16): [True: 0, False: 0]
  |  Branch (197:23): [True: 0, False: 0]
  ------------------
  198|      0|          *s++ = '0';
  199|      0|          num_digits--;
  200|      0|        }
  201|      0|      }
  202|      0|    }
  203|      0|    else {
  204|       |      // For e & g formats, we'll be printing the exponent, so set the
  205|       |      // sign.
  206|      0|      e_sign = e_sign_char;
  207|      0|      dec = 0;
  208|       |
  209|      0|      if (prec > (buf_remaining - FLT_MIN_BUF_SIZE)) {
  ------------------
  |  |   51|      0|#define FLT_MIN_BUF_SIZE  7 // -9e+199
  ------------------
  |  Branch (209:11): [True: 0, False: 0]
  ------------------
  210|      0|        prec = buf_remaining - FLT_MIN_BUF_SIZE;
  ------------------
  |  |   51|      0|#define FLT_MIN_BUF_SIZE  7 // -9e+199
  ------------------
  211|      0|        if (fmt == 'g') {
  ------------------
  |  Branch (211:13): [True: 0, False: 0]
  ------------------
  212|      0|          prec++;
  213|      0|        }
  214|      0|      }
  215|      0|    }
  216|      0|  }
  217|      1|  else {
  218|       |    // Build positive exponent
  219|     10|    for (e = 0, e1 = FLT_DECEXP; e1; e1 >>= 1, pos_pow++, neg_pow++) {
  ------------------
  |  |   49|      1|#define FLT_DECEXP      256
  ------------------
  |  Branch (219:34): [True: 9, False: 1]
  ------------------
  220|      9|      if (*pos_pow <= f) {
  ------------------
  |  Branch (220:11): [True: 3, False: 6]
  ------------------
  221|      3|        e += e1;
  222|      3|        f *= *neg_pow;
  223|      3|      }
  224|      9|    }
  225|       |
  226|       |    // If the user specified fixed format (fmt == 'f') and e makes the
  227|       |    // number too big to fit into the available buffer, then we'll
  228|       |    // switch to the 'e' format.
  229|       |
  230|      1|    if (fmt == 'f') {
  ------------------
  |  Branch (230:9): [True: 0, False: 1]
  ------------------
  231|      0|      if (e >= buf_remaining) {
  ------------------
  |  Branch (231:11): [True: 0, False: 0]
  ------------------
  232|      0|        fmt = 'e';
  233|      0|      }
  234|      0|      else if ((e + prec + 2) > buf_remaining) {
  ------------------
  |  Branch (234:16): [True: 0, False: 0]
  ------------------
  235|      0|        prec = buf_remaining - e - 2;
  236|      0|        if (prec < 0) {
  ------------------
  |  Branch (236:13): [True: 0, False: 0]
  ------------------
  237|       |          // This means no decimal point, so we can add one back
  238|       |          // for the decimal.
  239|      0|          prec++;
  240|      0|        }
  241|      0|      }
  242|      0|    }
  243|      1|    if (fmt == 'e' && prec > (buf_remaining - 6)) {
  ------------------
  |  Branch (243:9): [True: 0, False: 1]
  |  Branch (243:23): [True: 0, False: 0]
  ------------------
  244|      0|      prec = buf_remaining - 6;
  245|      0|    }
  246|       |    // If the user specified 'g' format, and e is < prec, then we'll switch
  247|       |    // to the fixed format.
  248|       |
  249|      1|    if (fmt == 'g' && e < prec) {
  ------------------
  |  Branch (249:9): [True: 1, False: 0]
  |  Branch (249:23): [True: 0, False: 1]
  ------------------
  250|      0|      fmt = 'f';
  251|      0|      prec -= (e + 1);
  252|      0|    }
  253|      1|    if (fmt == 'f') {
  ------------------
  |  Branch (253:9): [True: 0, False: 1]
  ------------------
  254|      0|      dec = e;
  255|      0|      num_digits = prec + e + 1;
  256|      0|    }
  257|      1|    else {
  258|      1|      e_sign = '+';
  259|      1|    }
  260|      1|  }
  261|      1|  if (prec < 0) {
  ------------------
  |  Branch (261:7): [True: 0, False: 1]
  ------------------
  262|       |    // This can happen when the prec is trimmed to prevent buffer overflow
  263|      0|    prec = 0;
  264|      0|  }
  265|       |
  266|       |  // We now have f as a floating-point number between >= 1 and < 10
  267|       |  // (or equal to zero), and e contains the absolute value of the power of
  268|       |  // 10 exponent. and (dec + 1) == the number of dgits before the decimal.
  269|       |
  270|       |  // For e, prec is # digits after the decimal
  271|       |  // For f, prec is # digits after the decimal
  272|       |  // For g, prec is the max number of significant digits
  273|       |  //
  274|       |  // For e & g there will be a single digit before the decimal
  275|       |  // for f there will be e digits before the decimal
  276|       |
  277|      1|  if (fmt == 'e') {
  ------------------
  |  Branch (277:7): [True: 0, False: 1]
  ------------------
  278|      0|    num_digits = prec + 1;
  279|      0|    if (prec == 0) prec = 1;
  ------------------
  |  Branch (279:9): [True: 0, False: 0]
  ------------------
  280|      0|  }
  281|      1|  else if (fmt == 'g') {
  ------------------
  |  Branch (281:12): [True: 1, False: 0]
  ------------------
  282|      1|    num_digits = prec;
  283|      1|  }
  284|       |
  285|       |  // Print the digits of the mantissa
  286|     16|  for (int i = 0; i < num_digits; i++,dec--) {
  ------------------
  |  Branch (286:19): [True: 15, False: 1]
  ------------------
  287|     15|    int8_t d = (int8_t)((int)f)%10;
  288|     15|    *s++ = '0' + d;
  289|     15|    if (dec == 0 && (prec > 0 || alt_form)) {
  ------------------
  |  Branch (289:9): [True: 1, False: 14]
  |  Branch (289:22): [True: 1, False: 0]
  |  Branch (289:34): [True: 0, False: 0]
  ------------------
  290|      1|      *s++ = '.';
  291|      1|    }
  292|     15|    f -= (mrb_float)d;
  293|     15|    f *= 10.0;
  294|     15|  }
  295|       |
  296|       |  // Round
  297|      1|  if (f >= 5.0) {
  ------------------
  |  Branch (297:7): [True: 0, False: 1]
  ------------------
  298|      0|    char *rs = s;
  299|      0|    rs--;
  300|      0|    while (1) {
  ------------------
  |  Branch (300:12): [Folded - Ignored]
  ------------------
  301|      0|      if (*rs == '.') {
  ------------------
  |  Branch (301:11): [True: 0, False: 0]
  ------------------
  302|      0|        rs--;
  303|      0|        continue;
  304|      0|      }
  305|      0|      if (*rs < '0' || *rs > '9') {
  ------------------
  |  Branch (305:11): [True: 0, False: 0]
  |  Branch (305:24): [True: 0, False: 0]
  ------------------
  306|       |        // + or -
  307|      0|        rs++; // So we sit on the digit to the right of the sign
  308|      0|        break;
  309|      0|      }
  310|      0|      if (*rs < '9') {
  ------------------
  |  Branch (310:11): [True: 0, False: 0]
  ------------------
  311|      0|        (*rs)++;
  312|      0|        break;
  313|      0|      }
  314|      0|      *rs = '0';
  315|      0|      if (rs == buf) {
  ------------------
  |  Branch (315:11): [True: 0, False: 0]
  ------------------
  316|      0|        break;
  317|      0|      }
  318|      0|      rs--;
  319|      0|    }
  320|      0|    if (*rs == '0') {
  ------------------
  |  Branch (320:9): [True: 0, False: 0]
  ------------------
  321|       |      // We need to insert a 1
  322|      0|      if (rs[1] == '.' && fmt != 'f') {
  ------------------
  |  Branch (322:11): [True: 0, False: 0]
  |  Branch (322:27): [True: 0, False: 0]
  ------------------
  323|       |        // We're going to round 9.99 to 10.00
  324|       |        // Move the decimal point
  325|      0|        rs[0] = '.';
  326|      0|        rs[1] = '0';
  327|      0|        if (e_sign == '-') {
  ------------------
  |  Branch (327:13): [True: 0, False: 0]
  ------------------
  328|      0|          e--;
  329|      0|        }
  330|      0|        else {
  331|      0|          e++;
  332|      0|        }
  333|      0|      }
  334|      0|      s++;
  335|      0|      char *ss = s;
  336|      0|      while (ss > rs) {
  ------------------
  |  Branch (336:14): [True: 0, False: 0]
  ------------------
  337|      0|        *ss = ss[-1];
  338|      0|        ss--;
  339|      0|      }
  340|      0|      *rs = '1';
  341|      0|      if (f < 1.0 && fmt == 'f') {
  ------------------
  |  Branch (341:11): [True: 0, False: 0]
  |  Branch (341:22): [True: 0, False: 0]
  ------------------
  342|       |        // We rounded up to 1.0
  343|      0|        prec--;
  344|      0|      }
  345|      0|    }
  346|      0|  }
  347|       |
  348|      1|  if (org_fmt == 'g' && prec > 0 && !alt_form) {
  ------------------
  |  Branch (348:7): [True: 1, False: 0]
  |  Branch (348:25): [True: 1, False: 0]
  |  Branch (348:37): [True: 1, False: 0]
  ------------------
  349|       |    // Remove trailing zeros and a trailing decimal point
  350|      1|    while (s[-1] == '0') {
  ------------------
  |  Branch (350:12): [True: 0, False: 1]
  ------------------
  351|      0|      s--;
  352|      0|    }
  353|      1|    if (s[-1] == '.') {
  ------------------
  |  Branch (353:9): [True: 0, False: 1]
  ------------------
  354|      0|      s--;
  355|      0|    }
  356|      1|  }
  357|       |  // Append the exponent
  358|      1|  if (e_sign) {
  ------------------
  |  Branch (358:7): [True: 1, False: 0]
  ------------------
  359|      1|    *s++ = e_char;
  360|      1|    *s++ = e_sign;
  361|      1|    if (e >= 100) {
  ------------------
  |  Branch (361:9): [True: 0, False: 1]
  ------------------
  362|      0|      *s++ = '0' + (e / 100);
  363|      0|      e %= 100;
  364|      0|    }
  365|      1|    *s++ = '0' + (e / 10);
  366|      1|    *s++ = '0' + (e % 10);
  367|      1|  }
  368|      1|  *s = '\0';
  369|       |
  370|      1|  return (int)(s - buf);
  371|      1|}

mrb_realloc_simple:
  185|  1.79M|{
  186|  1.79M|  void *p2;
  187|       |
  188|       |#if defined(MRB_GC_STRESS) && defined(MRB_DEBUG)
  189|       |  mrb_full_gc(mrb);
  190|       |#endif
  191|  1.79M|  p2 = (mrb->allocf)(mrb, p, len, mrb->allocf_ud);
  192|  1.79M|  if (!p2 && len > 0 && mrb->gc.heaps) {
  ------------------
  |  Branch (192:7): [True: 4.08k, False: 1.79M]
  |  Branch (192:14): [True: 13, False: 4.06k]
  |  Branch (192:25): [True: 13, False: 0]
  ------------------
  193|     13|    mrb_full_gc(mrb);
  194|     13|    p2 = (mrb->allocf)(mrb, p, len, mrb->allocf_ud);
  195|     13|  }
  196|       |
  197|  1.79M|  return p2;
  198|  1.79M|}
mrb_realloc:
  202|  1.71M|{
  203|  1.71M|  void *p2;
  204|       |
  205|  1.71M|  p2 = mrb_realloc_simple(mrb, p, len);
  206|  1.71M|  if (len == 0) return p2;
  ------------------
  |  Branch (206:7): [True: 0, False: 1.71M]
  ------------------
  207|  1.71M|  if (p2 == NULL) {
  ------------------
  |  Branch (207:7): [True: 13, False: 1.71M]
  ------------------
  208|     13|    mrb->gc.out_of_memory = TRUE;
  ------------------
  |  |   54|     13|#  define TRUE 1
  ------------------
  209|     13|    mrb_raise_nomemory(mrb);
  210|     13|  }
  211|  1.71M|  else {
  212|  1.71M|    mrb->gc.out_of_memory = FALSE;
  ------------------
  |  |   51|  1.71M|#  define FALSE 0
  ------------------
  213|  1.71M|  }
  214|       |
  215|  1.71M|  return p2;
  216|  1.71M|}
mrb_malloc:
  220|  1.54M|{
  221|  1.54M|  return mrb_realloc(mrb, 0, len);
  222|  1.54M|}
mrb_malloc_simple:
  226|  49.3k|{
  227|  49.3k|  return mrb_realloc_simple(mrb, 0, len);
  228|  49.3k|}
mrb_calloc:
  232|   734k|{
  233|   734k|  void *p;
  234|       |
  235|   734k|  if (nelem > 0 && len > 0 &&
  ------------------
  |  Branch (235:7): [True: 734k, False: 0]
  |  Branch (235:20): [True: 734k, False: 0]
  ------------------
  236|   734k|      nelem <= SIZE_MAX / len) {
  ------------------
  |  Branch (236:7): [True: 734k, False: 0]
  ------------------
  237|   734k|    size_t size;
  238|   734k|    size = nelem * len;
  239|   734k|    p = mrb_malloc(mrb, size);
  240|       |
  241|   734k|    memset(p, 0, size);
  242|   734k|  }
  243|      0|  else {
  244|      0|    p = NULL;
  245|      0|  }
  246|       |
  247|   734k|  return p;
  248|   734k|}
mrb_free:
  252|  1.83M|{
  253|  1.83M|  (mrb->allocf)(mrb, p, 0, mrb->allocf_ud);
  254|  1.83M|}
mrb_object_dead_p:
  284|  16.3M|{
  285|  16.3M|  mrb_gc *gc = &mrb->gc;
  286|  16.3M|  if (!heap_p(gc, object)) return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (286:7): [True: 0, False: 16.3M]
  ------------------
  287|  16.3M|  return is_dead(gc, object);
  ------------------
  |  |  173|  16.3M|#define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE)
  |  |  ------------------
  |  |  |  |  172|  16.3M|#define other_white_part(s) ((s)->current_white_part ^ GC_WHITES)
  |  |  |  |  ------------------
  |  |  |  |  |  |  159|  16.3M|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|  16.3M|#define GC_WHITE_A 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  156|  16.3M|#define GC_WHITE_B (1 << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE)
  |  |  ------------------
  |  |  |  |  159|  16.3M|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|  16.3M|#define GC_WHITE_A 1
  |  |  |  |  ------------------
  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|  16.3M|#define GC_WHITE_B (1 << 1)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 952k, False: 15.3M]
  |  |  |  Branch (173:74): [True: 2.20M, False: 13.1M]
  |  |  ------------------
  ------------------
  288|  16.3M|}
mrb_gc_init:
  363|  1.74k|{
  364|  1.74k|#ifndef MRB_GC_FIXED_ARENA
  365|  1.74k|  gc->arena = (struct RBasic**)mrb_malloc(mrb, sizeof(struct RBasic*)*MRB_GC_ARENA_SIZE);
  ------------------
  |  |   28|  1.74k|#define MRB_GC_ARENA_SIZE 100
  ------------------
  366|  1.74k|  gc->arena_capa = MRB_GC_ARENA_SIZE;
  ------------------
  |  |   28|  1.74k|#define MRB_GC_ARENA_SIZE 100
  ------------------
  367|  1.74k|#endif
  368|       |
  369|  1.74k|  gc->current_white_part = GC_WHITE_A;
  ------------------
  |  |  155|  1.74k|#define GC_WHITE_A 1
  ------------------
  370|  1.74k|  gc->heaps = NULL;
  371|  1.74k|  gc->free_heaps = NULL;
  372|  1.74k|  add_heap(mrb, gc);
  373|  1.74k|  gc->interval_ratio = DEFAULT_GC_INTERVAL_RATIO;
  ------------------
  |  |  353|  1.74k|#define DEFAULT_GC_INTERVAL_RATIO 200
  ------------------
  374|  1.74k|  gc->step_ratio = DEFAULT_GC_STEP_RATIO;
  ------------------
  |  |  354|  1.74k|#define DEFAULT_GC_STEP_RATIO 200
  ------------------
  375|  1.74k|#ifndef MRB_GC_TURN_OFF_GENERATIONAL
  376|  1.74k|  gc->generational = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
  377|  1.74k|  gc->full = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
  378|  1.74k|#endif
  379|  1.74k|}
mrb_gc_destroy:
  403|  1.74k|{
  404|  1.74k|  free_heap(mrb, gc);
  405|  1.74k|#ifndef MRB_GC_FIXED_ARENA
  406|  1.74k|  mrb_free(mrb, gc->arena);
  407|  1.74k|#endif
  408|  1.74k|}
mrb_gc_protect:
  433|   710k|{
  434|   710k|  if (mrb_immediate_p(obj)) return;
  ------------------
  |  |  148|   710k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  1.42M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 253k, False: 457k]
  |  |  |  Branch (148:63): [True: 161k, False: 295k]
  |  |  ------------------
  ------------------
  435|   295k|  struct RBasic *p = mrb_basic_ptr(obj);
  ------------------
  |  |   22|   295k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   295k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  436|   295k|  if (is_red(p)) return;
  ------------------
  |  |  170|   295k|#define is_red(o) ((o)->color == GC_RED)
  |  |  ------------------
  |  |  |  |  158|   295k|#define GC_RED MRB_GC_RED
  |  |  |  |  ------------------
  |  |  |  |  |  |   90|   295k|#define MRB_GC_RED 7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (170:19): [True: 0, False: 295k]
  |  |  ------------------
  ------------------
  437|   295k|  gc_protect(mrb, &mrb->gc, p);
  438|   295k|}
mrb_obj_alloc:
  499|  2.34M|{
  500|  2.34M|  struct RBasic *p;
  501|  2.34M|  static const RVALUE RVALUE_zero = { { { NULL, NULL, MRB_TT_FALSE } } };
  502|  2.34M|  mrb_gc *gc = &mrb->gc;
  503|       |
  504|  2.34M|  if (cls) {
  ------------------
  |  Branch (504:7): [True: 2.18M, False: 160k]
  ------------------
  505|  2.18M|    enum mrb_vtype tt;
  506|       |
  507|  2.18M|    switch (cls->tt) {
  508|  2.18M|    case MRB_TT_CLASS:
  ------------------
  |  Branch (508:5): [True: 2.18M, False: 0]
  ------------------
  509|  2.18M|    case MRB_TT_SCLASS:
  ------------------
  |  Branch (509:5): [True: 0, False: 2.18M]
  ------------------
  510|  2.18M|    case MRB_TT_MODULE:
  ------------------
  |  Branch (510:5): [True: 0, False: 2.18M]
  ------------------
  511|  2.18M|    case MRB_TT_ENV:
  ------------------
  |  Branch (511:5): [True: 0, False: 2.18M]
  ------------------
  512|  2.18M|      break;
  513|      0|    default:
  ------------------
  |  Branch (513:5): [True: 0, False: 2.18M]
  ------------------
  514|      0|      mrb_raise(mrb, E_TYPE_ERROR, "allocation failure");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  515|  2.18M|    }
  516|  2.18M|    tt = MRB_INSTANCE_TT(cls);
  ------------------
  |  |   76|  2.18M|#define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
  |  |  ------------------
  |  |  |  |   74|  2.18M|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  517|  2.18M|    if (tt != MRB_TT_FALSE &&
  ------------------
  |  Branch (517:9): [True: 2.14M, False: 38.8k]
  ------------------
  518|  2.18M|        tt != MRB_TT_UNDEF &&
  ------------------
  |  Branch (518:9): [True: 2.09M, False: 53.6k]
  ------------------
  519|  2.18M|        ttype != MRB_TT_SCLASS &&
  ------------------
  |  Branch (519:9): [True: 1.94M, False: 148k]
  ------------------
  520|  2.18M|        ttype != MRB_TT_ICLASS &&
  ------------------
  |  Branch (520:9): [True: 1.91M, False: 29.6k]
  ------------------
  521|  2.18M|        ttype != MRB_TT_ENV &&
  ------------------
  |  Branch (521:9): [True: 1.91M, False: 0]
  ------------------
  522|  2.18M|        ttype != MRB_TT_BIGINT &&
  ------------------
  |  Branch (522:9): [True: 1.91M, False: 0]
  ------------------
  523|  2.18M|        ttype != tt) {
  ------------------
  |  Branch (523:9): [True: 0, False: 1.91M]
  ------------------
  524|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "allocation failure of %C", cls);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  525|      0|    }
  526|  2.18M|  }
  527|  2.34M|  if (ttype <= MRB_TT_FREE) {
  ------------------
  |  Branch (527:7): [True: 0, False: 2.34M]
  ------------------
  528|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "allocation failure of %C (type %d)", cls, (int)ttype);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  529|      0|  }
  530|       |
  531|       |#ifdef MRB_GC_STRESS
  532|       |  mrb_full_gc(mrb);
  533|       |#endif
  534|  2.34M|  if (gc->threshold < gc->live) {
  ------------------
  |  Branch (534:7): [True: 2.48k, False: 2.34M]
  ------------------
  535|  2.48k|    mrb_incremental_gc(mrb);
  536|  2.48k|  }
  537|  2.34M|  if (gc->free_heaps == NULL) {
  ------------------
  |  Branch (537:7): [True: 875, False: 2.34M]
  ------------------
  538|    875|    add_heap(mrb, gc);
  539|    875|  }
  540|       |
  541|  2.34M|  p = gc->free_heaps->freelist;
  542|  2.34M|  gc->free_heaps->freelist = ((struct free_obj*)p)->next;
  543|  2.34M|  if (gc->free_heaps->freelist == NULL) {
  ------------------
  |  Branch (543:7): [True: 1.27k, False: 2.34M]
  ------------------
  544|  1.27k|    unlink_free_heap_page(gc, gc->free_heaps);
  545|  1.27k|  }
  546|       |
  547|  2.34M|  gc->live++;
  548|  2.34M|  gc_protect(mrb, gc, p);
  549|  2.34M|  *(RVALUE*)p = RVALUE_zero;
  550|  2.34M|  p->tt = ttype;
  551|  2.34M|  p->c = cls;
  552|  2.34M|  paint_partial_white(gc, p);
  ------------------
  |  |  166|  2.34M|#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
  ------------------
  553|  2.34M|  return p;
  554|  2.34M|}
mrb_gc_mark:
  741|  47.6M|{
  742|  47.6M|  if (obj == 0) return;
  ------------------
  |  Branch (742:7): [True: 10.2M, False: 37.4M]
  ------------------
  743|  37.4M|  if (!is_white(obj)) return;
  ------------------
  |  |  168|  37.4M|#define is_white(o) ((o)->color & GC_WHITES)
  |  |  ------------------
  |  |  |  |  159|  37.4M|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|  37.4M|#define GC_WHITE_A 1
  |  |  |  |  ------------------
  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|  37.4M|#define GC_WHITE_B (1 << 1)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (743:7): [True: 22.7M, False: 14.6M]
  ------------------
  744|  14.6M|  if (is_red(obj)) return;
  ------------------
  |  |  170|  14.6M|#define is_red(o) ((o)->color == GC_RED)
  |  |  ------------------
  |  |  |  |  158|  14.6M|#define GC_RED MRB_GC_RED
  |  |  |  |  ------------------
  |  |  |  |  |  |   90|  14.6M|#define MRB_GC_RED 7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (170:19): [True: 1.06M, False: 13.6M]
  |  |  ------------------
  ------------------
  745|  13.6M|  mrb_assert((obj)->tt != MRB_TT_FREE);
  ------------------
  |  |   68|  13.6M|#define mrb_assert(p) ((void)0)
  ------------------
  746|  13.6M|  add_gray_list(mrb, &mrb->gc, obj);
  747|  13.6M|}
mrb_incremental_gc:
 1256|  2.48k|{
 1257|  2.48k|  mrb_gc *gc = &mrb->gc;
 1258|       |
 1259|  2.48k|  if (gc->disabled || gc->iterating) return;
  ------------------
  |  Branch (1259:7): [True: 0, False: 2.48k]
  |  Branch (1259:23): [True: 0, False: 2.48k]
  ------------------
 1260|       |
 1261|  2.48k|  if (is_minor_gc(gc)) {
  ------------------
  |  |  359|  2.48k|#define is_minor_gc(gc) (is_generational(gc) && !(gc)->full)
  |  |  ------------------
  |  |  |  |  357|  4.96k|#define is_generational(gc) ((gc)->generational)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:29): [True: 2.48k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (359:49): [True: 575, False: 1.90k]
  |  |  ------------------
  ------------------
 1262|    575|    incremental_gc_finish(mrb, gc);
 1263|    575|  }
 1264|  1.90k|  else {
 1265|  1.90k|    incremental_gc_step(mrb, gc);
 1266|  1.90k|  }
 1267|       |
 1268|  2.48k|  if (gc->state == MRB_GC_STATE_ROOT) {
  ------------------
  |  Branch (1268:7): [True: 2.34k, False: 141]
  ------------------
 1269|  2.34k|    mrb_assert(gc->live >= gc->live_after_mark);
  ------------------
  |  |   68|  2.34k|#define mrb_assert(p) ((void)0)
  ------------------
 1270|  2.34k|    gc->threshold = (gc->live_after_mark/100) * gc->interval_ratio;
 1271|  2.34k|    if (gc->threshold < GC_STEP_SIZE) {
  ------------------
  |  |  151|  2.34k|#define GC_STEP_SIZE 1024
  ------------------
  |  Branch (1271:9): [True: 1.74k, False: 597]
  ------------------
 1272|  1.74k|      gc->threshold = GC_STEP_SIZE;
  ------------------
  |  |  151|  1.74k|#define GC_STEP_SIZE 1024
  ------------------
 1273|  1.74k|    }
 1274|       |
 1275|  2.34k|    if (is_major_gc(gc)) {
  ------------------
  |  |  358|  2.34k|#define is_major_gc(gc) (is_generational(gc) && (gc)->full)
  |  |  ------------------
  |  |  |  |  357|  4.68k|#define is_generational(gc) ((gc)->generational)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:29): [True: 2.34k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (358:49): [True: 1.76k, False: 575]
  |  |  ------------------
  ------------------
 1276|  1.76k|      size_t threshold = gc->live_after_mark/100 * MAJOR_GC_INC_RATIO;
  ------------------
  |  |  355|  1.76k|#define MAJOR_GC_INC_RATIO 120
  ------------------
 1277|       |
 1278|  1.76k|      gc->full = FALSE;
  ------------------
  |  |   51|  1.76k|#  define FALSE 0
  ------------------
 1279|  1.76k|      if (threshold < MAJOR_GC_TOOMANY) {
  ------------------
  |  |  356|  1.76k|#define MAJOR_GC_TOOMANY 10000
  ------------------
  |  Branch (1279:11): [True: 1.76k, False: 0]
  ------------------
 1280|  1.76k|        gc->majorgc_old_threshold = threshold;
 1281|  1.76k|      }
 1282|      0|      else {
 1283|       |        /* too many objects allocated during incremental GC, */
 1284|       |        /* instead of increasing threshold, invoke full GC. */
 1285|      0|        mrb_full_gc(mrb);
 1286|      0|      }
 1287|  1.76k|    }
 1288|    575|    else if (is_minor_gc(gc)) {
  ------------------
  |  |  359|    575|#define is_minor_gc(gc) (is_generational(gc) && !(gc)->full)
  |  |  ------------------
  |  |  |  |  357|  1.15k|#define is_generational(gc) ((gc)->generational)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:29): [True: 575, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (359:49): [True: 575, False: 0]
  |  |  ------------------
  ------------------
 1289|    575|      if (gc->live > gc->majorgc_old_threshold) {
  ------------------
  |  Branch (1289:11): [True: 446, False: 129]
  ------------------
 1290|    446|        clear_all_old(mrb, gc);
 1291|    446|        gc->full = TRUE;
  ------------------
  |  |   54|    446|#  define TRUE 1
  ------------------
 1292|    446|      }
 1293|    575|    }
 1294|  2.34k|  }
 1295|  2.48k|}
mrb_full_gc:
 1300|  15.6k|{
 1301|  15.6k|  mrb_gc *gc = &mrb->gc;
 1302|       |
 1303|  15.6k|  if (!mrb->c) return;
  ------------------
  |  Branch (1303:7): [True: 0, False: 15.6k]
  ------------------
 1304|  15.6k|  if (gc->disabled || gc->iterating) return;
  ------------------
  |  Branch (1304:7): [True: 0, False: 15.6k]
  |  Branch (1304:23): [True: 0, False: 15.6k]
  ------------------
 1305|       |
 1306|  15.6k|  if (is_generational(gc)) {
  ------------------
  |  |  357|  15.6k|#define is_generational(gc) ((gc)->generational)
  |  |  ------------------
  |  |  |  Branch (357:29): [True: 15.6k, False: 0]
  |  |  ------------------
  ------------------
 1307|       |    /* clear all the old objects back to young */
 1308|  15.6k|    clear_all_old(mrb, gc);
 1309|  15.6k|    gc->full = TRUE;
  ------------------
  |  |   54|  15.6k|#  define TRUE 1
  ------------------
 1310|  15.6k|  }
 1311|      0|  else if (gc->state != MRB_GC_STATE_ROOT) {
  ------------------
  |  Branch (1311:12): [True: 0, False: 0]
  ------------------
 1312|       |    /* finish half baked GC cycle */
 1313|      0|    incremental_gc_finish(mrb, gc);
 1314|      0|  }
 1315|       |
 1316|  15.6k|  incremental_gc_finish(mrb, gc);
 1317|  15.6k|  gc->threshold = (gc->live_after_mark/100) * gc->interval_ratio;
 1318|       |
 1319|  15.6k|  if (is_generational(gc)) {
  ------------------
  |  |  357|  15.6k|#define is_generational(gc) ((gc)->generational)
  |  |  ------------------
  |  |  |  Branch (357:29): [True: 15.6k, False: 0]
  |  |  ------------------
  ------------------
 1320|  15.6k|    gc->majorgc_old_threshold = gc->live_after_mark/100 * MAJOR_GC_INC_RATIO;
  ------------------
  |  |  355|  15.6k|#define MAJOR_GC_INC_RATIO 120
  ------------------
 1321|  15.6k|    gc->full = FALSE;
  ------------------
  |  |   51|  15.6k|#  define FALSE 0
  ------------------
 1322|  15.6k|  }
 1323|       |
 1324|       |#ifdef MRB_USE_MALLOC_TRIM
 1325|       |  malloc_trim(0);
 1326|       |#endif
 1327|  15.6k|}
mrb_field_write_barrier:
 1342|  3.26M|{
 1343|  3.26M|  mrb_gc *gc = &mrb->gc;
 1344|       |
 1345|  3.26M|  if (!value) return;
  ------------------
  |  Branch (1345:7): [True: 0, False: 3.26M]
  ------------------
 1346|  3.26M|  if (!is_black(obj)) return;
  ------------------
  |  |  169|  3.26M|#define is_black(o) ((o)->color == GC_BLACK)
  |  |  ------------------
  |  |  |  |  157|  3.26M|#define GC_BLACK (1 << 2)
  |  |  ------------------
  ------------------
  |  Branch (1346:7): [True: 3.23M, False: 32.1k]
  ------------------
 1347|  32.1k|  if (!is_white(value)) return;
  ------------------
  |  |  168|  32.1k|#define is_white(o) ((o)->color & GC_WHITES)
  |  |  ------------------
  |  |  |  |  159|  32.1k|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|  32.1k|#define GC_WHITE_A 1
  |  |  |  |  ------------------
  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|  32.1k|#define GC_WHITE_B (1 << 1)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1347:7): [True: 5.09k, False: 27.0k]
  ------------------
 1348|  27.0k|  if (is_red(value)) return;
  ------------------
  |  |  170|  27.0k|#define is_red(o) ((o)->color == GC_RED)
  |  |  ------------------
  |  |  |  |  158|  27.0k|#define GC_RED MRB_GC_RED
  |  |  |  |  ------------------
  |  |  |  |  |  |   90|  27.0k|#define MRB_GC_RED 7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (170:19): [True: 0, False: 27.0k]
  |  |  ------------------
  ------------------
 1349|       |
 1350|  27.0k|  mrb_assert(gc->state == MRB_GC_STATE_MARK || (!is_dead(gc, value) && !is_dead(gc, obj)));
  ------------------
  |  |   68|  27.0k|#define mrb_assert(p) ((void)0)
  ------------------
 1351|  27.0k|  mrb_assert(is_generational(gc) || gc->state != MRB_GC_STATE_ROOT);
  ------------------
  |  |   68|  27.0k|#define mrb_assert(p) ((void)0)
  ------------------
 1352|       |
 1353|  27.0k|  if (is_generational(gc) || gc->state == MRB_GC_STATE_MARK) {
  ------------------
  |  |  357|  54.0k|#define is_generational(gc) ((gc)->generational)
  |  |  ------------------
  |  |  |  Branch (357:29): [True: 27.0k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1353:30): [True: 0, False: 0]
  ------------------
 1354|  27.0k|    add_gray_list(mrb, gc, value);
 1355|  27.0k|  }
 1356|      0|  else {
 1357|      0|    mrb_assert(gc->state == MRB_GC_STATE_SWEEP);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1358|      0|    paint_partial_white(gc, obj); /* for never write barriers */
  ------------------
  |  |  166|      0|#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
  ------------------
 1359|      0|  }
 1360|  27.0k|}
mrb_write_barrier:
 1373|  64.1k|{
 1374|  64.1k|  mrb_gc *gc = &mrb->gc;
 1375|       |
 1376|  64.1k|  if (!is_black(obj)) return;
  ------------------
  |  |  169|  64.1k|#define is_black(o) ((o)->color == GC_BLACK)
  |  |  ------------------
  |  |  |  |  157|  64.1k|#define GC_BLACK (1 << 2)
  |  |  ------------------
  ------------------
  |  Branch (1376:7): [True: 64.1k, False: 38]
  ------------------
 1377|       |
 1378|     38|  mrb_assert(!is_dead(gc, obj));
  ------------------
  |  |   68|     38|#define mrb_assert(p) ((void)0)
  ------------------
 1379|     38|  mrb_assert(is_generational(gc) || gc->state != MRB_GC_STATE_ROOT);
  ------------------
  |  |   68|     38|#define mrb_assert(p) ((void)0)
  ------------------
 1380|     38|  paint_gray(obj);
  ------------------
  |  |  163|     38|#define paint_gray(o) ((o)->color = GC_GRAY)
  |  |  ------------------
  |  |  |  |  154|     38|#define GC_GRAY 0
  |  |  ------------------
  ------------------
 1381|     38|  obj->gcnext = gc->atomic_gray_list;
 1382|     38|  gc->atomic_gray_list = obj;
 1383|     38|}
mrb_objspace_each_objects:
 1587|  15.6k|{
 1588|  15.6k|  mrb_bool iterating = mrb->gc.iterating;
 1589|       |
 1590|  15.6k|  mrb_full_gc(mrb);
 1591|  15.6k|  mrb->gc.iterating = TRUE;
  ------------------
  |  |   54|  15.6k|#  define TRUE 1
  ------------------
 1592|  15.6k|  if (iterating) {
  ------------------
  |  Branch (1592:7): [True: 0, False: 15.6k]
  ------------------
 1593|      0|    gc_each_objects(mrb, &mrb->gc, callback, data);
 1594|      0|  }
 1595|  15.6k|  else {
 1596|  15.6k|    struct mrb_jmpbuf *prev_jmp = mrb->jmp;
 1597|  15.6k|    struct mrb_jmpbuf c_jmp;
 1598|       |
 1599|  15.6k|    MRB_TRY(&c_jmp) {
  ------------------
  |  |   44|  15.6k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  15.6k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 15.6k, False: 0]
  |  |  ------------------
  ------------------
 1600|  15.6k|      mrb->jmp = &c_jmp;
 1601|  15.6k|      gc_each_objects(mrb, &mrb->gc, callback, data);
 1602|  15.6k|      mrb->jmp = prev_jmp;
 1603|  15.6k|      mrb->gc.iterating = iterating;
 1604|  15.6k|    } MRB_CATCH(&c_jmp) {
  ------------------
  |  |   45|  15.6k|#define MRB_CATCH(buf) } else {
  ------------------
 1605|      0|      mrb->gc.iterating = iterating;
 1606|      0|      mrb->jmp = prev_jmp;
 1607|      0|      MRB_THROW(prev_jmp);
  ------------------
  |  |   48|      0|#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
  |  |  ------------------
  |  |  |  |   41|      0|#define MRB_LONGJMP longjmp
  |  |  ------------------
  ------------------
 1608|  15.6k|    } MRB_END_EXC(&c_jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
 1609|  15.6k|  }
 1610|  15.6k|}
mrb_init_gc:
 1621|  1.74k|{
 1622|  1.74k|  struct RClass *gc;
 1623|       |
 1624|  1.74k|  mrb_static_assert_object_size(RVALUE);
  ------------------
  |  |   44|  1.74k|  mrb_static_assert(sizeof(st) <= sizeof(void*) * 6, \
  |  |  ------------------
  |  |  |  |  109|  1.74k|    mrb_static_assert_expand(mrb_static_assert_selector(__VA_ARGS__, mrb_static_assert2, mrb_static_assert1, _)(__VA_ARGS__))
  |  |  |  |  ------------------
  |  |  |  |  |  |   99|  1.74k|# define mrb_static_assert_expand(...) __VA_ARGS__ /* for MSVC behaviour - https://stackoverflow.com/q/5530505 */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|  1.74k|                    #st " size must be within 6 words")
  ------------------
 1625|       |
 1626|  1.74k|  gc = mrb_define_module(mrb, "GC");
 1627|       |
 1628|  1.74k|  mrb_define_class_method(mrb, gc, "start", gc_start, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1629|  1.74k|  mrb_define_class_method(mrb, gc, "enable", gc_enable, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1630|  1.74k|  mrb_define_class_method(mrb, gc, "disable", gc_disable, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1631|  1.74k|  mrb_define_class_method(mrb, gc, "interval_ratio", gc_interval_ratio_get, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1632|  1.74k|  mrb_define_class_method(mrb, gc, "interval_ratio=", gc_interval_ratio_set, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1633|  1.74k|  mrb_define_class_method(mrb, gc, "step_ratio", gc_step_ratio_get, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1634|  1.74k|  mrb_define_class_method(mrb, gc, "step_ratio=", gc_step_ratio_set, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1635|  1.74k|  mrb_define_class_method(mrb, gc, "generational_mode=", gc_generational_mode_set, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1636|  1.74k|  mrb_define_class_method(mrb, gc, "generational_mode", gc_generational_mode_get, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1637|  1.74k|}
gc.c:heap_p:
  266|  16.3M|{
  267|  16.3M|  mrb_heap_page* page;
  268|       |
  269|  16.3M|  page = gc->heaps;
  270|  16.8M|  while (page) {
  ------------------
  |  Branch (270:10): [True: 16.8M, False: 0]
  ------------------
  271|  16.8M|    RVALUE *p;
  272|       |
  273|  16.8M|    p = objects(page);
  ------------------
  |  |  179|  16.8M|#define objects(p) ((RVALUE*)&p[1])
  ------------------
  274|  16.8M|    if (&p[0].as.basic <= object && object <= &p[MRB_HEAP_PAGE_SIZE - 1].as.basic) {
  ------------------
  |  |  148|  16.4M|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
  |  Branch (274:9): [True: 16.4M, False: 404k]
  |  Branch (274:37): [True: 16.3M, False: 90.1k]
  ------------------
  275|  16.3M|      return TRUE;
  ------------------
  |  |   54|  16.3M|#  define TRUE 1
  ------------------
  276|  16.3M|    }
  277|   494k|    page = page->next;
  278|   494k|  }
  279|      0|  return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  280|  16.3M|}
gc.c:add_heap:
  337|  2.62k|{
  338|  2.62k|  mrb_heap_page *page = (mrb_heap_page*)mrb_calloc(mrb, 1, sizeof(mrb_heap_page) + MRB_HEAP_PAGE_SIZE * sizeof(RVALUE));
  ------------------
  |  |  148|  2.62k|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
  339|  2.62k|  RVALUE *p, *e;
  340|  2.62k|  struct RBasic *prev = NULL;
  341|       |
  342|  2.68M|  for (p = objects(page), e=p+MRB_HEAP_PAGE_SIZE; p<e; p++) {
  ------------------
  |  |  179|  2.62k|#define objects(p) ((RVALUE*)&p[1])
  ------------------
                for (p = objects(page), e=p+MRB_HEAP_PAGE_SIZE; p<e; p++) {
  ------------------
  |  |  148|  2.62k|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
  |  Branch (342:51): [True: 2.68M, False: 2.62k]
  ------------------
  343|  2.68M|    p->as.free.tt = MRB_TT_FREE;
  344|  2.68M|    p->as.free.next = prev;
  345|  2.68M|    prev = &p->as.basic;
  346|  2.68M|  }
  347|  2.62k|  page->freelist = prev;
  348|       |
  349|  2.62k|  link_heap_page(gc, page);
  350|  2.62k|  link_free_heap_page(gc, page);
  351|  2.62k|}
gc.c:link_heap_page:
  292|  2.62k|{
  293|  2.62k|  page->next = gc->heaps;
  294|  2.62k|  if (gc->heaps)
  ------------------
  |  Branch (294:7): [True: 875, False: 1.74k]
  ------------------
  295|    875|    gc->heaps->prev = page;
  296|  2.62k|  gc->heaps = page;
  297|  2.62k|}
gc.c:link_free_heap_page:
  314|  3.71k|{
  315|  3.71k|  page->free_next = gc->free_heaps;
  316|  3.71k|  if (gc->free_heaps) {
  ------------------
  |  Branch (316:7): [True: 802, False: 2.91k]
  ------------------
  317|    802|    gc->free_heaps->free_prev = page;
  318|    802|  }
  319|  3.71k|  gc->free_heaps = page;
  320|  3.71k|}
gc.c:free_heap:
  385|  1.74k|{
  386|  1.74k|  mrb_heap_page *page = gc->heaps;
  387|  1.74k|  mrb_heap_page *tmp;
  388|  1.74k|  RVALUE *p, *e;
  389|       |
  390|  3.84k|  while (page) {
  ------------------
  |  Branch (390:10): [True: 2.09k, False: 1.74k]
  ------------------
  391|  2.09k|    tmp = page;
  392|  2.09k|    page = page->next;
  393|  2.14M|    for (p = objects(tmp), e=p+MRB_HEAP_PAGE_SIZE; p<e; p++) {
  ------------------
  |  |  179|  2.09k|#define objects(p) ((RVALUE*)&p[1])
  ------------------
                  for (p = objects(tmp), e=p+MRB_HEAP_PAGE_SIZE; p<e; p++) {
  ------------------
  |  |  148|  2.09k|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
  |  Branch (393:52): [True: 2.14M, False: 2.09k]
  ------------------
  394|  2.14M|      if (p->as.free.tt != MRB_TT_FREE)
  ------------------
  |  Branch (394:11): [True: 1.68M, False: 461k]
  ------------------
  395|  1.68M|        obj_free(mrb, &p->as.basic, TRUE);
  ------------------
  |  |   54|  1.68M|#  define TRUE 1
  ------------------
  396|  2.14M|    }
  397|  2.09k|    mrb_free(mrb, tmp);
  398|  2.09k|  }
  399|  1.74k|}
gc.c:obj_free:
  751|  2.34M|{
  752|  2.34M|  DEBUG(fprintf(stderr, "obj_free(%p,tt=%d)\n",obj,obj->tt));
  753|  2.34M|  switch (obj->tt) {
  754|  28.3k|  case MRB_TT_OBJECT:
  ------------------
  |  Branch (754:3): [True: 28.3k, False: 2.31M]
  ------------------
  755|  28.3k|    mrb_gc_free_iv(mrb, (struct RObject*)obj);
  756|  28.3k|    break;
  757|       |
  758|  4.12k|  case MRB_TT_EXCEPTION:
  ------------------
  |  Branch (758:3): [True: 4.12k, False: 2.34M]
  ------------------
  759|  4.12k|    mrb_gc_free_iv(mrb, (struct RObject*)obj);
  760|  4.12k|    break;
  761|       |
  762|   129k|  case MRB_TT_CLASS:
  ------------------
  |  Branch (762:3): [True: 129k, False: 2.21M]
  ------------------
  763|   146k|  case MRB_TT_MODULE:
  ------------------
  |  Branch (763:3): [True: 17.4k, False: 2.32M]
  ------------------
  764|   303k|  case MRB_TT_SCLASS:
  ------------------
  |  Branch (764:3): [True: 157k, False: 2.18M]
  ------------------
  765|   303k|    mrb_gc_free_mt(mrb, (struct RClass*)obj);
  766|   303k|    mrb_gc_free_iv(mrb, (struct RObject*)obj);
  767|   303k|    if (!end)
  ------------------
  |  Branch (767:9): [True: 0, False: 303k]
  ------------------
  768|      0|      mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
  769|   303k|    break;
  770|  29.6k|  case MRB_TT_ICLASS:
  ------------------
  |  Branch (770:3): [True: 29.6k, False: 2.31M]
  ------------------
  771|  29.6k|    if (MRB_FLAG_TEST(obj, MRB_FL_CLASS_IS_ORIGIN))
  ------------------
  |  |   17|  29.6k|#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & (flag))
  |  |  ------------------
  |  |  |  Branch (17:34): [True: 0, False: 29.6k]
  |  |  ------------------
  ------------------
  772|      0|      mrb_gc_free_mt(mrb, (struct RClass*)obj);
  773|  29.6k|    if (!end)
  ------------------
  |  Branch (773:9): [True: 0, False: 29.6k]
  ------------------
  774|      0|      mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
  775|  29.6k|    break;
  776|   153k|  case MRB_TT_ENV:
  ------------------
  |  Branch (776:3): [True: 153k, False: 2.19M]
  ------------------
  777|   153k|    {
  778|   153k|      struct REnv *e = (struct REnv*)obj;
  779|       |
  780|   153k|      if (MRB_ENV_ONSTACK_P(e)) {
  ------------------
  |  |   30|   153k|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|   153k|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  |  |  |  Branch (30:30): [True: 85.5k, False: 68.0k]
  |  |  ------------------
  ------------------
  781|       |        /* cannot be freed */
  782|  85.5k|        e->stack = NULL;
  783|  85.5k|        break;
  784|  85.5k|      }
  785|  68.0k|      mrb_free(mrb, e->stack);
  786|  68.0k|      e->stack = NULL;
  787|  68.0k|    }
  788|      0|    break;
  789|       |
  790|      0|  case MRB_TT_FIBER:
  ------------------
  |  Branch (790:3): [True: 0, False: 2.34M]
  ------------------
  791|      0|    {
  792|      0|      struct mrb_context *c = ((struct RFiber*)obj)->cxt;
  793|       |
  794|      0|      if (c && c != mrb->root_c) {
  ------------------
  |  Branch (794:11): [True: 0, False: 0]
  |  Branch (794:16): [True: 0, False: 0]
  ------------------
  795|      0|        if (!end && c->status != MRB_FIBER_TERMINATED) {
  ------------------
  |  Branch (795:13): [True: 0, False: 0]
  |  Branch (795:21): [True: 0, False: 0]
  ------------------
  796|      0|          mrb_callinfo *ci = c->ci;
  797|      0|          mrb_callinfo *ce = c->cibase;
  798|       |
  799|      0|          while (ce <= ci) {
  ------------------
  |  Branch (799:18): [True: 0, False: 0]
  ------------------
  800|      0|            struct REnv *e = ci->u.env;
  801|      0|            if (e && !mrb_object_dead_p(mrb, (struct RBasic*)e) &&
  ------------------
  |  Branch (801:17): [True: 0, False: 0]
  |  Branch (801:22): [True: 0, False: 0]
  ------------------
  802|      0|                e->tt == MRB_TT_ENV && MRB_ENV_ONSTACK_P(e)) {
  ------------------
  |  |   30|      0|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  |  |  |  Branch (30:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (802:17): [True: 0, False: 0]
  ------------------
  803|      0|              mrb_env_unshare(mrb, e, TRUE);
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  804|      0|            }
  805|      0|            ci--;
  806|      0|          }
  807|      0|        }
  808|      0|        mrb_free_context(mrb, c);
  809|      0|      }
  810|      0|    }
  811|      0|    break;
  812|       |
  813|      0|  case MRB_TT_STRUCT:
  ------------------
  |  Branch (813:3): [True: 0, False: 2.34M]
  ------------------
  814|   292k|  case MRB_TT_ARRAY:
  ------------------
  |  Branch (814:3): [True: 292k, False: 2.05M]
  ------------------
  815|   292k|    if (ARY_SHARED_P(obj))
  ------------------
  |  |   84|   292k|#define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
  |  |  ------------------
  |  |  |  |   83|   292k|#define MRB_ARY_SHARED      256
  |  |  ------------------
  |  |  |  Branch (84:25): [True: 590, False: 291k]
  |  |  ------------------
  ------------------
  816|    590|      mrb_ary_decref(mrb, ((struct RArray*)obj)->as.heap.aux.shared);
  817|   291k|    else if (!ARY_EMBED_P(obj))
  ------------------
  |  |   63|   291k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  ------------------
  |  |  |  |   62|   291k|#define MRB_ARY_EMBED_MASK  7
  |  |  ------------------
  ------------------
  |  Branch (817:14): [True: 21.5k, False: 270k]
  ------------------
  818|  21.5k|      mrb_free(mrb, ((struct RArray*)obj)->as.heap.ptr);
  819|   292k|    break;
  820|       |
  821|  58.8k|  case MRB_TT_HASH:
  ------------------
  |  Branch (821:3): [True: 58.8k, False: 2.28M]
  ------------------
  822|  58.8k|    mrb_gc_free_iv(mrb, (struct RObject*)obj);
  823|  58.8k|    mrb_gc_free_hash(mrb, (struct RHash*)obj);
  824|  58.8k|    break;
  825|       |
  826|   403k|  case MRB_TT_STRING:
  ------------------
  |  Branch (826:3): [True: 403k, False: 1.94M]
  ------------------
  827|   403k|    mrb_gc_free_str(mrb, (struct RString*)obj);
  828|   403k|    break;
  829|       |
  830|  1.00M|  case MRB_TT_PROC:
  ------------------
  |  Branch (830:3): [True: 1.00M, False: 1.34M]
  ------------------
  831|  1.00M|    {
  832|  1.00M|      struct RProc *p = (struct RProc*)obj;
  833|       |
  834|  1.00M|      if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
  ------------------
  |  |   65|  2.00M|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|  1.00M|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  ------------------
  |  Branch (834:11): [True: 959k, False: 43.6k]
  |  Branch (834:35): [True: 959k, False: 0]
  ------------------
  835|   959k|        mrb_irep *irep = (mrb_irep*)p->body.irep;
  836|   959k|        if (end) {
  ------------------
  |  Branch (836:13): [True: 935k, False: 23.4k]
  ------------------
  837|   935k|          mrb_irep_cutref(mrb, irep);
  838|   935k|        }
  839|   959k|        mrb_irep_decref(mrb, irep);
  840|   959k|      }
  841|  1.00M|    }
  842|  1.00M|    break;
  843|       |
  844|      0|  case MRB_TT_RANGE:
  ------------------
  |  Branch (844:3): [True: 0, False: 2.34M]
  ------------------
  845|      0|    mrb_gc_free_range(mrb, ((struct RRange*)obj));
  ------------------
  |  |   28|      0|# define mrb_gc_free_range(mrb, p) ((void)0)
  ------------------
  846|      0|    break;
  847|       |
  848|  13.2k|  case MRB_TT_CDATA:
  ------------------
  |  Branch (848:3): [True: 13.2k, False: 2.33M]
  ------------------
  849|  13.2k|    {
  850|  13.2k|      struct RData *d = (struct RData*)obj;
  851|  13.2k|      if (d->type && d->type->dfree) {
  ------------------
  |  Branch (851:11): [True: 13.2k, False: 0]
  |  Branch (851:22): [True: 13.2k, False: 0]
  ------------------
  852|  13.2k|        d->type->dfree(mrb, d->data);
  853|  13.2k|      }
  854|  13.2k|      mrb_gc_free_iv(mrb, (struct RObject*)obj);
  855|  13.2k|    }
  856|  13.2k|    break;
  857|       |
  858|       |#if defined(MRB_USE_RATIONAL) && defined(MRB_INT64) && defined(MRB_32BIT)
  859|       |  case MRB_TT_RATIONAL:
  860|       |    {
  861|       |      struct RData *o = (struct RData*)obj;
  862|       |      mrb_free(mrb, o->iv);
  863|       |    }
  864|       |    break;
  865|       |#endif
  866|       |
  867|       |#if defined(MRB_USE_COMPLEX) && defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32)
  868|       |  case MRB_TT_COMPLEX:
  869|       |    {
  870|       |      struct RData *o = (struct RData*)obj;
  871|       |      mrb_free(mrb, o->iv);
  872|       |    }
  873|       |    break;
  874|       |#endif
  875|       |
  876|      0|#ifdef MRB_USE_BIGINT
  877|  48.1k|  case MRB_TT_BIGINT:
  ------------------
  |  Branch (877:3): [True: 48.1k, False: 2.29M]
  ------------------
  878|  48.1k|    mrb_gc_free_bint(mrb, obj);
  879|  48.1k|    break;
  880|      0|#endif
  881|       |
  882|  7.22k|  default:
  ------------------
  |  Branch (882:3): [True: 7.22k, False: 2.33M]
  ------------------
  883|  7.22k|    break;
  884|  2.34M|  }
  885|       |#if defined(MRB_GC_STRESS) && defined(MRB_DEBUG)
  886|       |  memset(obj, -1, sizeof(RVALUE));
  887|       |  paint_white(obj);
  888|       |#endif
  889|  2.34M|  obj->tt = MRB_TT_FREE;
  890|  2.34M|}
gc.c:gc_protect:
  412|  2.64M|{
  413|       |#ifdef MRB_GC_FIXED_ARENA
  414|       |  if (gc->arena_idx >= MRB_GC_ARENA_SIZE) {
  415|       |    /* arena overflow error */
  416|       |    gc->arena_idx = MRB_GC_ARENA_SIZE - 4; /* force room in arena */
  417|       |    mrb_exc_raise(mrb, mrb_obj_value(mrb->arena_err));
  418|       |  }
  419|       |#else
  420|  2.64M|  if (gc->arena_idx >= gc->arena_capa) {
  ------------------
  |  Branch (420:7): [True: 363, False: 2.64M]
  ------------------
  421|       |    /* extend arena */
  422|    363|    int newcapa = gc->arena_capa * 3 / 2;
  423|    363|    gc->arena = (struct RBasic**)mrb_realloc(mrb, gc->arena, sizeof(struct RBasic*)*newcapa);
  424|    363|    gc->arena_capa = newcapa;
  425|    363|  }
  426|  2.64M|#endif
  427|  2.64M|  gc->arena[gc->arena_idx++] = p;
  428|  2.64M|}
gc.c:unlink_free_heap_page:
  324|  1.80k|{
  325|  1.80k|  if (page->free_prev)
  ------------------
  |  Branch (325:7): [True: 225, False: 1.57k]
  ------------------
  326|    225|    page->free_prev->free_next = page->free_next;
  327|  1.80k|  if (page->free_next)
  ------------------
  |  Branch (327:7): [True: 478, False: 1.32k]
  ------------------
  328|    478|    page->free_next->free_prev = page->free_prev;
  329|  1.80k|  if (gc->free_heaps == page)
  ------------------
  |  Branch (329:7): [True: 1.57k, False: 225]
  ------------------
  330|  1.57k|    gc->free_heaps = page->free_next;
  331|  1.80k|  page->free_prev = NULL;
  332|  1.80k|  page->free_next = NULL;
  333|  1.80k|}
gc.c:add_gray_list:
  558|  13.6M|{
  559|       |#ifdef MRB_GC_STRESS
  560|       |  if (obj->tt > MRB_TT_MAXDEFINE) {
  561|       |    abort();
  562|       |  }
  563|       |#endif
  564|  13.6M|  paint_gray(obj);
  ------------------
  |  |  163|  13.6M|#define paint_gray(o) ((o)->color = GC_GRAY)
  |  |  ------------------
  |  |  |  |  154|  13.6M|#define GC_GRAY 0
  |  |  ------------------
  ------------------
  565|  13.6M|  obj->gcnext = gc->gray_list;
  566|  13.6M|  gc->gray_list = obj;
  567|  13.6M|}
gc.c:incremental_gc_finish:
 1214|  32.3k|{
 1215|   113k|  do {
 1216|   113k|    incremental_gc(mrb, gc, SIZE_MAX);
 1217|   113k|  } while (gc->state != MRB_GC_STATE_ROOT);
  ------------------
  |  Branch (1217:12): [True: 81.3k, False: 32.3k]
  ------------------
 1218|  32.3k|}
gc.c:incremental_gc:
 1182|   122k|{
 1183|   122k|  switch (gc->state) {
 1184|  18.2k|  case MRB_GC_STATE_ROOT:
  ------------------
  |  Branch (1184:3): [True: 18.2k, False: 104k]
  ------------------
 1185|  18.2k|    root_scan_phase(mrb, gc);
 1186|  18.2k|    gc->state = MRB_GC_STATE_MARK;
 1187|  18.2k|    flip_white_part(gc);
  ------------------
  |  |  171|  18.2k|#define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
  |  |  ------------------
  |  |  |  |  172|  18.2k|#define other_white_part(s) ((s)->current_white_part ^ GC_WHITES)
  |  |  |  |  ------------------
  |  |  |  |  |  |  159|  18.2k|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|  18.2k|#define GC_WHITE_A 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  156|  18.2k|#define GC_WHITE_B (1 << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1188|  18.2k|    return 0;
 1189|  36.3k|  case MRB_GC_STATE_MARK:
  ------------------
  |  Branch (1189:3): [True: 36.3k, False: 86.4k]
  ------------------
 1190|  36.3k|    if (gc->gray_list) {
  ------------------
  |  Branch (1190:9): [True: 18.0k, False: 18.2k]
  ------------------
 1191|  18.0k|      return incremental_marking_phase(mrb, gc, limit);
 1192|  18.0k|    }
 1193|  18.2k|    else {
 1194|  18.2k|      final_marking_phase(mrb, gc);
 1195|  18.2k|      prepare_incremental_sweep(mrb, gc);
 1196|  18.2k|      return 0;
 1197|  18.2k|    }
 1198|  68.1k|  case MRB_GC_STATE_SWEEP: {
  ------------------
  |  Branch (1198:3): [True: 68.1k, False: 54.5k]
  ------------------
 1199|  68.1k|     size_t tried_sweep = 0;
 1200|  68.1k|     tried_sweep = incremental_sweep_phase(mrb, gc, limit);
 1201|  68.1k|     if (tried_sweep == 0)
  ------------------
  |  Branch (1201:10): [True: 34.0k, False: 34.1k]
  ------------------
 1202|  34.0k|       gc->state = MRB_GC_STATE_ROOT;
 1203|  68.1k|     return tried_sweep;
 1204|  36.3k|  }
 1205|      0|  default:
  ------------------
  |  Branch (1205:3): [True: 0, False: 122k]
  ------------------
 1206|       |    /* unknown state */
 1207|      0|    mrb_assert(0);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1208|      0|    return 0;
 1209|   122k|  }
 1210|   122k|}
gc.c:root_scan_phase:
  894|  18.2k|{
  895|  18.2k|  int i, e;
  896|       |
  897|  18.2k|  if (!is_minor_gc(gc)) {
  ------------------
  |  |  359|  18.2k|#define is_minor_gc(gc) (is_generational(gc) && !(gc)->full)
  |  |  ------------------
  |  |  |  |  357|  36.5k|#define is_generational(gc) ((gc)->generational)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:29): [True: 18.2k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (359:49): [True: 575, False: 17.6k]
  |  |  ------------------
  ------------------
  898|  17.6k|    gc->gray_list = NULL;
  899|  17.6k|    gc->atomic_gray_list = NULL;
  900|  17.6k|  }
  901|       |
  902|  18.2k|  mrb_gc_mark_gv(mrb);
  903|       |  /* mark arena */
  904|  68.5k|  for (i=0,e=gc->arena_idx; i<e; i++) {
  ------------------
  |  Branch (904:29): [True: 50.3k, False: 18.2k]
  ------------------
  905|  50.3k|    mrb_gc_mark(mrb, gc->arena[i]);
  906|  50.3k|  }
  907|       |  /* mark class hierarchy */
  908|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->object_class);
  909|       |
  910|       |  /* mark built-in classes */
  911|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->class_class);
  912|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->module_class);
  913|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->proc_class);
  914|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->string_class);
  915|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->array_class);
  916|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->hash_class);
  917|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->range_class);
  918|       |
  919|  18.2k|#ifndef MRB_NO_FLOAT
  920|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class);
  921|  18.2k|#endif
  922|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->integer_class);
  923|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->true_class);
  924|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->false_class);
  925|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->nil_class);
  926|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->symbol_class);
  927|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->kernel_module);
  928|       |
  929|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->eException_class);
  930|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->eStandardError_class);
  931|       |
  932|       |  /* mark top_self */
  933|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->top_self);
  934|       |  /* mark exception */
  935|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->exc);
  936|       |
  937|  18.2k|  mark_context(mrb, mrb->c);
  938|  18.2k|  if (mrb->root_c != mrb->c) {
  ------------------
  |  Branch (938:7): [True: 0, False: 18.2k]
  ------------------
  939|      0|    mark_context(mrb, mrb->root_c);
  940|      0|  }
  941|  18.2k|}
gc.c:mark_context:
  601|  36.4k|{
  602|  36.4k|  mrb_callinfo *ci;
  603|       |
  604|  36.4k| start:
  605|  36.4k|  if (c->status == MRB_FIBER_TERMINATED) return;
  ------------------
  |  Branch (605:7): [True: 0, False: 36.4k]
  ------------------
  606|       |
  607|       |  /* mark VM stack */
  608|  36.4k|  mark_context_stack(mrb, c);
  609|       |
  610|       |  /* mark call stack */
  611|  36.4k|  if (c->cibase) {
  ------------------
  |  Branch (611:7): [True: 32.9k, False: 3.49k]
  ------------------
  612|   132k|    for (ci = c->cibase; ci <= c->ci; ci++) {
  ------------------
  |  Branch (612:26): [True: 99.0k, False: 32.9k]
  ------------------
  613|  99.0k|      mrb_gc_mark(mrb, (struct RBasic*)ci->proc);
  614|  99.0k|      mrb_gc_mark(mrb, (struct RBasic*)ci->u.target_class);
  615|  99.0k|    }
  616|  32.9k|  }
  617|       |  /* mark fibers */
  618|  36.4k|  mrb_gc_mark(mrb, (struct RBasic*)c->fib);
  619|  36.4k|  if (c->prev) {
  ------------------
  |  Branch (619:7): [True: 0, False: 36.4k]
  ------------------
  620|      0|    c = c->prev;
  621|      0|    goto start;
  622|      0|  }
  623|  36.4k|}
gc.c:mark_context_stack:
  571|  36.4k|{
  572|  36.4k|  size_t i;
  573|  36.4k|  size_t e;
  574|  36.4k|  mrb_value nil;
  575|       |
  576|  36.4k|  if (c->stbase == NULL) return;
  ------------------
  |  Branch (576:7): [True: 3.49k, False: 32.9k]
  ------------------
  577|  32.9k|  if (c->ci) {
  ------------------
  |  Branch (577:7): [True: 32.9k, False: 0]
  ------------------
  578|  32.9k|    e = (c->ci->stack ? c->ci->stack - c->stbase : 0);
  ------------------
  |  Branch (578:10): [True: 32.9k, False: 0]
  ------------------
  579|  32.9k|    e += mrb_ci_nregs(c->ci);
  580|  32.9k|  }
  581|      0|  else {
  582|      0|    e = 0;
  583|      0|  }
  584|  32.9k|  if (c->stbase + e > c->stend) e = c->stend - c->stbase;
  ------------------
  |  Branch (584:7): [True: 0, False: 32.9k]
  ------------------
  585|  2.02M|  for (i=0; i<e; i++) {
  ------------------
  |  Branch (585:13): [True: 1.98M, False: 32.9k]
  ------------------
  586|  1.98M|    mrb_value v = c->stbase[i];
  587|       |
  588|  1.98M|    if (!mrb_immediate_p(v)) {
  ------------------
  |  |  148|  1.98M|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|  3.97M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 410k, False: 1.57M]
  |  |  |  Branch (148:63): [True: 1.22M, False: 352k]
  |  |  ------------------
  ------------------
  589|   352k|      mrb_gc_mark(mrb, mrb_basic_ptr(v));
  ------------------
  |  |   22|   352k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   352k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  590|   352k|    }
  591|  1.98M|  }
  592|  32.9k|  e = c->stend - c->stbase;
  593|  32.9k|  nil = mrb_nil_value();
  594|  5.48M|  for (; i<e; i++) {
  ------------------
  |  Branch (594:10): [True: 5.44M, False: 32.9k]
  ------------------
  595|  5.44M|    c->stbase[i] = nil;
  596|  5.44M|  }
  597|  32.9k|}
gc.c:incremental_marking_phase:
 1045|  18.0k|{
 1046|  18.0k|  size_t tried_marks = 0;
 1047|       |
 1048|  13.6M|  while (gc->gray_list && tried_marks < limit) {
  ------------------
  |  Branch (1048:10): [True: 13.6M, False: 17.9k]
  |  Branch (1048:27): [True: 13.6M, False: 101]
  ------------------
 1049|  13.6M|    struct RBasic *obj = gc->gray_list;
 1050|  13.6M|    gc->gray_list = obj->gcnext;
 1051|  13.6M|    gc_mark_children(mrb, gc, obj);
 1052|  13.6M|    tried_marks += gc_gray_counts(mrb, gc, obj);
 1053|  13.6M|  }
 1054|       |
 1055|  18.0k|  return tried_marks;
 1056|  18.0k|}
gc.c:gc_mark_children:
  627|  13.6M|{
  628|  13.6M|  mrb_assert(is_gray(obj));
  ------------------
  |  |   68|  13.6M|#define mrb_assert(p) ((void)0)
  ------------------
  629|  13.6M|  paint_black(obj);
  ------------------
  |  |  164|  13.6M|#define paint_black(o) ((o)->color = GC_BLACK)
  |  |  ------------------
  |  |  |  |  157|  13.6M|#define GC_BLACK (1 << 2)
  |  |  ------------------
  ------------------
  630|  13.6M|  mrb_gc_mark(mrb, (struct RBasic*)obj->c);
  631|  13.6M|  switch (obj->tt) {
  632|   273k|  case MRB_TT_ICLASS:
  ------------------
  |  Branch (632:3): [True: 273k, False: 13.3M]
  ------------------
  633|   273k|    {
  634|   273k|      struct RClass *c = (struct RClass*)obj;
  635|   273k|      if (MRB_FLAG_TEST(c, MRB_FL_CLASS_IS_ORIGIN))
  ------------------
  |  |   17|   273k|#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & (flag))
  |  |  ------------------
  |  |  |  Branch (17:34): [True: 0, False: 273k]
  |  |  ------------------
  ------------------
  636|      0|        mrb_gc_mark_mt(mrb, c);
  637|   273k|      mrb_gc_mark(mrb, (struct RBasic*)((struct RClass*)obj)->super);
  638|   273k|    }
  639|   273k|    break;
  640|       |
  641|  1.19M|  case MRB_TT_CLASS:
  ------------------
  |  Branch (641:3): [True: 1.19M, False: 12.4M]
  ------------------
  642|  1.35M|  case MRB_TT_MODULE:
  ------------------
  |  Branch (642:3): [True: 160k, False: 13.4M]
  ------------------
  643|  2.79M|  case MRB_TT_SCLASS:
  ------------------
  |  Branch (643:3): [True: 1.44M, False: 12.1M]
  ------------------
  644|  2.79M|    {
  645|  2.79M|      struct RClass *c = (struct RClass*)obj;
  646|       |
  647|  2.79M|      mrb_gc_mark_mt(mrb, c);
  648|  2.79M|      mrb_gc_mark(mrb, (struct RBasic*)c->super);
  649|  2.79M|    }
  650|       |    /* fall through */
  651|       |
  652|  2.82M|  case MRB_TT_OBJECT:
  ------------------
  |  Branch (652:3): [True: 32.3k, False: 13.5M]
  ------------------
  653|  2.87M|  case MRB_TT_CDATA:
  ------------------
  |  Branch (653:3): [True: 48.4k, False: 13.5M]
  ------------------
  654|  2.87M|    mrb_gc_mark_iv(mrb, (struct RObject*)obj);
  655|  2.87M|    break;
  656|       |
  657|  8.79M|  case MRB_TT_PROC:
  ------------------
  |  Branch (657:3): [True: 8.79M, False: 4.83M]
  ------------------
  658|  8.79M|    {
  659|  8.79M|      struct RProc *p = (struct RProc*)obj;
  660|       |
  661|  8.79M|      mrb_gc_mark(mrb, (struct RBasic*)p->upper);
  662|  8.79M|      mrb_gc_mark(mrb, (struct RBasic*)p->e.env);
  663|  8.79M|    }
  664|  8.79M|    break;
  665|       |
  666|  1.20M|  case MRB_TT_ENV:
  ------------------
  |  Branch (666:3): [True: 1.20M, False: 12.4M]
  ------------------
  667|  1.20M|    {
  668|  1.20M|      struct REnv *e = (struct REnv*)obj;
  669|  1.20M|      mrb_int i, len;
  670|       |
  671|  1.20M|      if (MRB_ENV_ONSTACK_P(e) && e->cxt && e->cxt->fib) {
  ------------------
  |  |   30|  2.41M|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|  1.20M|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  |  |  |  Branch (30:30): [True: 787k, False: 417k]
  |  |  ------------------
  ------------------
  |  Branch (671:35): [True: 0, False: 787k]
  |  Branch (671:45): [True: 0, False: 0]
  ------------------
  672|      0|        mrb_gc_mark(mrb, (struct RBasic*)e->cxt->fib);
  673|      0|      }
  674|  1.20M|      len = MRB_ENV_LEN(e);
  ------------------
  |  |   27|  1.20M|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  675|  1.62M|      for (i=0; i<len; i++) {
  ------------------
  |  Branch (675:17): [True: 417k, False: 1.20M]
  ------------------
  676|   417k|        mrb_gc_mark_value(mrb, e->stack[i]);
  ------------------
  |  | 1313|   417k|#define mrb_gc_mark_value(mrb,val) do {\
  |  | 1314|   417k|  if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|   417k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   835k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 401k, False: 16.0k]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 16.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|  16.0k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  16.0k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1315|   417k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1315:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  677|   417k|      }
  678|  1.20M|    }
  679|  1.20M|    break;
  680|       |
  681|      0|  case MRB_TT_FIBER:
  ------------------
  |  Branch (681:3): [True: 0, False: 13.6M]
  ------------------
  682|      0|    {
  683|      0|      struct mrb_context *c = ((struct RFiber*)obj)->cxt;
  684|       |
  685|      0|      if (c) mark_context(mrb, c);
  ------------------
  |  Branch (685:11): [True: 0, False: 0]
  ------------------
  686|      0|    }
  687|      0|    break;
  688|       |
  689|      0|  case MRB_TT_STRUCT:
  ------------------
  |  Branch (689:3): [True: 0, False: 13.6M]
  ------------------
  690|  2.44k|  case MRB_TT_ARRAY:
  ------------------
  |  Branch (690:3): [True: 2.44k, False: 13.6M]
  ------------------
  691|  2.44k|    {
  692|  2.44k|      struct RArray *a = (struct RArray*)obj;
  693|  2.44k|      size_t i, e=ARY_LEN(a);
  ------------------
  |  |   70|  2.44k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  2.44k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.44k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 1.53k, False: 903]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  1.53k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  1.53k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  694|  2.44k|      mrb_value *p = ARY_PTR(a);
  ------------------
  |  |   71|  2.44k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  2.44k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.44k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 1.53k, False: 903]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  1.53k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
  695|       |
  696|  5.79k|      for (i=0; i<e; i++) {
  ------------------
  |  Branch (696:17): [True: 3.35k, False: 2.44k]
  ------------------
  697|  3.35k|        mrb_gc_mark_value(mrb, p[i]);
  ------------------
  |  | 1313|  3.35k|#define mrb_gc_mark_value(mrb,val) do {\
  |  | 1314|  3.35k|  if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|  3.35k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  6.71k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 2.77k, False: 581]
  |  |  |  |  |  Branch (148:63): [True: 79, False: 502]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|    502|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|    502|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1315|  3.35k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1315:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  698|  3.35k|      }
  699|  2.44k|    }
  700|  2.44k|    break;
  701|       |
  702|  17.4k|  case MRB_TT_HASH:
  ------------------
  |  Branch (702:3): [True: 17.4k, False: 13.6M]
  ------------------
  703|  17.4k|    mrb_gc_mark_iv(mrb, (struct RObject*)obj);
  704|  17.4k|    mrb_gc_mark_hash(mrb, (struct RHash*)obj);
  705|  17.4k|    break;
  706|       |
  707|   439k|  case MRB_TT_STRING:
  ------------------
  |  Branch (707:3): [True: 439k, False: 13.1M]
  ------------------
  708|   439k|    if (RSTR_FSHARED_P(obj)) {
  ------------------
  |  |   73|   439k|#define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
  |  |  ------------------
  |  |  |  |  108|   439k|#define MRB_STR_FSHARED   2
  |  |  ------------------
  |  |  |  Branch (73:27): [True: 0, False: 439k]
  |  |  ------------------
  ------------------
  709|      0|      struct RString *s = (struct RString*)obj;
  710|      0|      mrb_gc_mark(mrb, (struct RBasic*)s->as.heap.aux.fshared);
  711|      0|    }
  712|   439k|    break;
  713|       |
  714|      0|  case MRB_TT_RANGE:
  ------------------
  |  Branch (714:3): [True: 0, False: 13.6M]
  ------------------
  715|      0|    mrb_gc_mark_range(mrb, (struct RRange*)obj);
  716|      0|    break;
  717|       |
  718|      0|  case MRB_TT_BREAK:
  ------------------
  |  Branch (718:3): [True: 0, False: 13.6M]
  ------------------
  719|      0|    {
  720|      0|      struct RBreak *brk = (struct RBreak*)obj;
  721|      0|      mrb_gc_mark(mrb, (struct RBasic*)mrb_break_proc_get(brk));
  ------------------
  |  |   70|      0|#define mrb_break_proc_get(brk) ((brk)->proc)
  ------------------
  722|      0|      mrb_gc_mark_value(mrb, mrb_break_value_get(brk));
  ------------------
  |  | 1313|      0|#define mrb_gc_mark_value(mrb,val) do {\
  |  | 1314|      0|  if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|      0|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1315|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (1315:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  723|      0|    }
  724|      0|    break;
  725|       |
  726|      1|  case MRB_TT_EXCEPTION:
  ------------------
  |  Branch (726:3): [True: 1, False: 13.6M]
  ------------------
  727|      1|    mrb_gc_mark_iv(mrb, (struct RObject*)obj);
  728|      1|    if (((struct RException*)obj)->mesg) {
  ------------------
  |  Branch (728:9): [True: 1, False: 0]
  ------------------
  729|      1|      mrb_gc_mark(mrb, (struct RBasic*)((struct RException*)obj)->mesg);
  730|      1|    }
  731|      1|    mrb_gc_mark(mrb, (struct RBasic*)((struct RException*)obj)->backtrace);
  732|      1|    break;
  733|       |
  734|  19.6k|  default:
  ------------------
  |  Branch (734:3): [True: 19.6k, False: 13.6M]
  ------------------
  735|  19.6k|    break;
  736|  13.6M|  }
  737|  13.6M|}
gc.c:gc_gray_counts:
  946|  13.6M|{
  947|  13.6M|  size_t children = 0;
  948|       |
  949|  13.6M|  switch (obj->tt) {
  950|   273k|  case MRB_TT_ICLASS:
  ------------------
  |  Branch (950:3): [True: 273k, False: 13.3M]
  ------------------
  951|   273k|    children++;
  952|   273k|    break;
  953|       |
  954|  1.19M|  case MRB_TT_CLASS:
  ------------------
  |  Branch (954:3): [True: 1.19M, False: 12.4M]
  ------------------
  955|  2.63M|  case MRB_TT_SCLASS:
  ------------------
  |  Branch (955:3): [True: 1.44M, False: 12.1M]
  ------------------
  956|  2.79M|  case MRB_TT_MODULE:
  ------------------
  |  Branch (956:3): [True: 160k, False: 13.4M]
  ------------------
  957|  2.79M|    {
  958|  2.79M|      struct RClass *c = (struct RClass*)obj;
  959|       |
  960|  2.79M|      children += mrb_gc_mark_iv_size(mrb, (struct RObject*)obj);
  961|  2.79M|      children += mrb_gc_mark_mt_size(mrb, c);
  962|  2.79M|      children++;
  963|  2.79M|    }
  964|  2.79M|    break;
  965|       |
  966|  32.3k|  case MRB_TT_OBJECT:
  ------------------
  |  Branch (966:3): [True: 32.3k, False: 13.5M]
  ------------------
  967|  80.7k|  case MRB_TT_CDATA:
  ------------------
  |  Branch (967:3): [True: 48.4k, False: 13.5M]
  ------------------
  968|  80.7k|    children += mrb_gc_mark_iv_size(mrb, (struct RObject*)obj);
  969|  80.7k|    break;
  970|       |
  971|  1.20M|  case MRB_TT_ENV:
  ------------------
  |  Branch (971:3): [True: 1.20M, False: 12.4M]
  ------------------
  972|  1.20M|    children += MRB_ENV_LEN(obj);
  ------------------
  |  |   27|  1.20M|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  973|  1.20M|    break;
  974|       |
  975|      0|  case MRB_TT_FIBER:
  ------------------
  |  Branch (975:3): [True: 0, False: 13.6M]
  ------------------
  976|      0|    {
  977|      0|      struct mrb_context *c = ((struct RFiber*)obj)->cxt;
  978|      0|      size_t i;
  979|      0|      mrb_callinfo *ci;
  980|       |
  981|      0|      if (!c || c->status == MRB_FIBER_TERMINATED) break;
  ------------------
  |  Branch (981:11): [True: 0, False: 0]
  |  Branch (981:17): [True: 0, False: 0]
  ------------------
  982|      0|      if (!c->ci) break;
  ------------------
  |  Branch (982:11): [True: 0, False: 0]
  ------------------
  983|       |
  984|       |      /* mark stack */
  985|      0|      i = c->ci->stack - c->stbase;
  986|      0|      i += mrb_ci_nregs(c->ci);
  987|      0|      if (c->stbase + i > c->stend) i = c->stend - c->stbase;
  ------------------
  |  Branch (987:11): [True: 0, False: 0]
  ------------------
  988|      0|      children += i;
  989|       |
  990|       |      /* mark closure */
  991|      0|      if (c->cibase) {
  ------------------
  |  Branch (991:11): [True: 0, False: 0]
  ------------------
  992|      0|        for (i=0, ci = c->cibase; ci <= c->ci; i++, ci++)
  ------------------
  |  Branch (992:35): [True: 0, False: 0]
  ------------------
  993|      0|          ;
  994|      0|      }
  995|      0|      children += i;
  996|      0|    }
  997|      0|    break;
  998|       |
  999|      0|  case MRB_TT_STRUCT:
  ------------------
  |  Branch (999:3): [True: 0, False: 13.6M]
  ------------------
 1000|  2.37k|  case MRB_TT_ARRAY:
  ------------------
  |  Branch (1000:3): [True: 2.37k, False: 13.6M]
  ------------------
 1001|  2.37k|    {
 1002|  2.37k|      struct RArray *a = (struct RArray*)obj;
 1003|  2.37k|      children += ARY_LEN(a);
  ------------------
  |  |   70|  2.37k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  2.37k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  2.37k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 1.47k, False: 903]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  1.47k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  1.47k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1004|  2.37k|    }
 1005|  2.37k|    break;
 1006|       |
 1007|  17.4k|  case MRB_TT_HASH:
  ------------------
  |  Branch (1007:3): [True: 17.4k, False: 13.5M]
  ------------------
 1008|  17.4k|    children += mrb_gc_mark_iv_size(mrb, (struct RObject*)obj);
 1009|  17.4k|    children += mrb_gc_mark_hash_size(mrb, (struct RHash*)obj);
 1010|  17.4k|    break;
 1011|       |
 1012|  8.79M|  case MRB_TT_PROC:
  ------------------
  |  Branch (1012:3): [True: 8.79M, False: 4.81M]
  ------------------
 1013|  8.79M|  case MRB_TT_RANGE:
  ------------------
  |  Branch (1013:3): [True: 0, False: 13.6M]
  ------------------
 1014|  8.79M|  case MRB_TT_BREAK:
  ------------------
  |  Branch (1014:3): [True: 0, False: 13.6M]
  ------------------
 1015|  8.79M|    children+=2;
 1016|  8.79M|    break;
 1017|       |
 1018|      1|  case MRB_TT_EXCEPTION:
  ------------------
  |  Branch (1018:3): [True: 1, False: 13.6M]
  ------------------
 1019|      1|    children += mrb_gc_mark_iv_size(mrb, (struct RObject*)obj);
 1020|      1|    if (((struct RException*)obj)->mesg) {
  ------------------
  |  Branch (1020:9): [True: 1, False: 0]
  ------------------
 1021|      1|      children++;
 1022|      1|    }
 1023|      1|    if (((struct RException*)obj)->backtrace) {
  ------------------
  |  Branch (1023:9): [True: 0, False: 1]
  ------------------
 1024|      0|      children++;
 1025|      0|    }
 1026|      1|    break;
 1027|       |
 1028|   442k|  default:
  ------------------
  |  Branch (1028:3): [True: 442k, False: 13.1M]
  ------------------
 1029|   442k|    break;
 1030|  13.6M|  }
 1031|  13.6M|  return children;
 1032|  13.6M|}
gc.c:final_marking_phase:
 1074|  18.2k|{
 1075|  18.2k|  int i, e;
 1076|       |
 1077|       |  /* mark arena */
 1078|  63.1k|  for (i=0,e=gc->arena_idx; i<e; i++) {
  ------------------
  |  Branch (1078:29): [True: 44.9k, False: 18.2k]
  ------------------
 1079|  44.9k|    mrb_gc_mark(mrb, gc->arena[i]);
 1080|  44.9k|  }
 1081|  18.2k|  mrb_gc_mark_gv(mrb);
 1082|  18.2k|  mark_context(mrb, mrb->c);
 1083|  18.2k|  if (mrb->c != mrb->root_c) {
  ------------------
  |  Branch (1083:7): [True: 0, False: 18.2k]
  ------------------
 1084|      0|    mark_context(mrb, mrb->root_c);
 1085|      0|  }
 1086|  18.2k|  mrb_gc_mark(mrb, (struct RBasic*)mrb->exc);
 1087|       |
 1088|       |  /* mark pre-allocated exception */
 1089|  18.2k|  clear_error_object(mrb, mrb->nomem_err);
 1090|  18.2k|  clear_error_object(mrb, mrb->stack_err);
 1091|       |#ifdef MRB_GC_FIXED_ARENA
 1092|       |  clear_error_object(mrb, mrb->arena_err);
 1093|       |#endif
 1094|       |
 1095|  18.2k|  gc_mark_gray_list(mrb, gc);
 1096|  18.2k|  mrb_assert(gc->gray_list == NULL);
  ------------------
  |  |   68|  18.2k|#define mrb_assert(p) ((void)0)
  ------------------
 1097|  18.2k|  gc->gray_list = gc->atomic_gray_list;
 1098|  18.2k|  gc->atomic_gray_list = NULL;
 1099|  18.2k|  gc_mark_gray_list(mrb, gc);
 1100|  18.2k|  mrb_assert(gc->gray_list == NULL);
  ------------------
  |  |   68|  18.2k|#define mrb_assert(p) ((void)0)
  ------------------
 1101|  18.2k|}
gc.c:clear_error_object:
 1060|  36.4k|{
 1061|  36.4k|  if (obj == 0) return;
  ------------------
  |  Branch (1061:7): [True: 3.49k, False: 32.9k]
  ------------------
 1062|  32.9k|  if (!is_white(obj)) return;
  ------------------
  |  |  168|  32.9k|#define is_white(o) ((o)->color & GC_WHITES)
  |  |  ------------------
  |  |  |  |  159|  32.9k|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|  32.9k|#define GC_WHITE_A 1
  |  |  |  |  ------------------
  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|  32.9k|#define GC_WHITE_B (1 << 1)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1062:7): [True: 842, False: 32.1k]
  ------------------
 1063|  32.1k|  paint_black(obj);
  ------------------
  |  |  164|  32.1k|#define paint_black(o) ((o)->color = GC_BLACK)
  |  |  ------------------
  |  |  |  |  157|  32.1k|#define GC_BLACK (1 << 2)
  |  |  ------------------
  ------------------
 1064|  32.1k|  mrb_gc_mark(mrb, (struct RBasic*)obj->c);
 1065|  32.1k|  mrb_gc_free_iv(mrb, obj);
 1066|  32.1k|  struct RException *err = (struct RException*)obj;
 1067|  32.1k|  err->iv = NULL;
 1068|  32.1k|  err->mesg = NULL;
 1069|  32.1k|  err->backtrace = NULL;
 1070|  32.1k|}
gc.c:gc_mark_gray_list:
 1035|  36.4k|gc_mark_gray_list(mrb_state *mrb, mrb_gc *gc) {
 1036|  53.2k|  while (gc->gray_list) {
  ------------------
  |  Branch (1036:10): [True: 16.8k, False: 36.4k]
  ------------------
 1037|  16.8k|    struct RBasic *obj = gc->gray_list;
 1038|  16.8k|    gc->gray_list = obj->gcnext;
 1039|  16.8k|    gc_mark_children(mrb, gc, obj);
 1040|  16.8k|  }
 1041|  36.4k|}
gc.c:prepare_incremental_sweep:
 1105|  34.0k|{
 1106|       |  //  mrb_assert(gc->atomic_gray_list == NULL);
 1107|       |  //  mrb_assert(gc->gray_list == NULL);
 1108|  34.0k|  gc->state = MRB_GC_STATE_SWEEP;
 1109|  34.0k|  gc->sweeps = gc->heaps;
 1110|  34.0k|  gc->live_after_mark = gc->live;
 1111|  34.0k|}
gc.c:incremental_sweep_phase:
 1115|  68.1k|{
 1116|  68.1k|  mrb_heap_page *page = gc->sweeps;
 1117|  68.1k|  size_t tried_sweep = 0;
 1118|       |
 1119|   104k|  while (page && (tried_sweep < limit)) {
  ------------------
  |  Branch (1119:10): [True: 36.6k, False: 68.1k]
  |  Branch (1119:18): [True: 36.5k, False: 40]
  ------------------
 1120|  36.5k|    RVALUE *p = objects(page);
  ------------------
  |  |  179|  36.5k|#define objects(p) ((RVALUE*)&p[1])
  ------------------
 1121|  36.5k|    RVALUE *e = p + MRB_HEAP_PAGE_SIZE;
  ------------------
  |  |  148|  36.5k|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
 1122|  36.5k|    size_t freed = 0;
 1123|  36.5k|    mrb_bool dead_slot = TRUE;
  ------------------
  |  |   54|  36.5k|#  define TRUE 1
  ------------------
 1124|  36.5k|    mrb_bool full = (page->freelist == NULL);
 1125|       |
 1126|  36.5k|    if (is_minor_gc(gc) && page->old) {
  ------------------
  |  |  359|  73.1k|#define is_minor_gc(gc) (is_generational(gc) && !(gc)->full)
  |  |  ------------------
  |  |  |  |  357|  73.1k|#define is_generational(gc) ((gc)->generational)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:29): [True: 19.9k, False: 16.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (359:49): [True: 1.23k, False: 18.6k]
  |  |  ------------------
  ------------------
  |  Branch (1126:28): [True: 6, False: 1.22k]
  ------------------
 1127|       |      /* skip a slot which doesn't contain any young object */
 1128|      6|      p = e;
 1129|      6|      dead_slot = FALSE;
  ------------------
  |  |   51|      6|#  define FALSE 0
  ------------------
 1130|      6|    }
 1131|  37.4M|    while (p<e) {
  ------------------
  |  Branch (1131:12): [True: 37.4M, False: 36.5k]
  ------------------
 1132|  37.4M|      if (is_dead(gc, &p->as.basic)) {
  ------------------
  |  |  173|  37.4M|#define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE)
  |  |  ------------------
  |  |  |  |  172|  37.4M|#define other_white_part(s) ((s)->current_white_part ^ GC_WHITES)
  |  |  |  |  ------------------
  |  |  |  |  |  |  159|  37.4M|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|  37.4M|#define GC_WHITE_A 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  156|  37.4M|#define GC_WHITE_B (1 << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE)
  |  |  ------------------
  |  |  |  |  159|  37.4M|#define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|  37.4M|#define GC_WHITE_A 1
  |  |  |  |  ------------------
  |  |  |  |               #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|  37.4M|#define GC_WHITE_B (1 << 1)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (173:24): [True: 2.27M, False: 35.1M]
  |  |  |  Branch (173:74): [True: 7.39M, False: 27.7M]
  |  |  ------------------
  ------------------
 1133|  9.66M|        if (p->as.basic.tt != MRB_TT_FREE) {
  ------------------
  |  Branch (1133:13): [True: 659k, False: 9.01M]
  ------------------
 1134|   659k|          obj_free(mrb, &p->as.basic, FALSE);
  ------------------
  |  |   51|   659k|#  define FALSE 0
  ------------------
 1135|   659k|          if (p->as.basic.tt == MRB_TT_FREE) {
  ------------------
  |  Branch (1135:15): [True: 659k, False: 0]
  ------------------
 1136|   659k|            p->as.free.next = page->freelist;
 1137|   659k|            page->freelist = (struct RBasic*)p;
 1138|   659k|            freed++;
 1139|   659k|          }
 1140|      0|          else {
 1141|      0|            dead_slot = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 1142|      0|          }
 1143|   659k|        }
 1144|  9.66M|      }
 1145|  27.7M|      else {
 1146|  27.7M|        if (!is_generational(gc))
  ------------------
  |  |  357|  27.7M|#define is_generational(gc) ((gc)->generational)
  ------------------
  |  Branch (1146:13): [True: 13.7M, False: 14.0M]
  ------------------
 1147|  13.7M|          paint_partial_white(gc, &p->as.basic); /* next gc target */
  ------------------
  |  |  166|  13.7M|#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
  ------------------
 1148|  27.7M|        dead_slot = FALSE;
  ------------------
  |  |   51|  27.7M|#  define FALSE 0
  ------------------
 1149|  27.7M|      }
 1150|  37.4M|      p++;
 1151|  37.4M|    }
 1152|       |
 1153|       |    /* free dead slot */
 1154|  36.5k|    if (dead_slot && freed < MRB_HEAP_PAGE_SIZE) {
  ------------------
  |  |  148|    640|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
  |  Branch (1154:9): [True: 640, False: 35.9k]
  |  Branch (1154:22): [True: 523, False: 117]
  ------------------
 1155|    523|      mrb_heap_page *next = page->next;
 1156|       |
 1157|    523|      unlink_heap_page(gc, page);
 1158|    523|      unlink_free_heap_page(gc, page);
 1159|    523|      mrb_free(mrb, page);
 1160|    523|      page = next;
 1161|    523|    }
 1162|  36.0k|    else {
 1163|  36.0k|      if (full && freed > 0) {
  ------------------
  |  Branch (1163:11): [True: 1.62k, False: 34.4k]
  |  Branch (1163:19): [True: 1.09k, False: 524]
  ------------------
 1164|  1.09k|        link_free_heap_page(gc, page);
 1165|  1.09k|      }
 1166|  36.0k|      if (page->freelist == NULL && is_minor_gc(gc))
  ------------------
  |  |  359|    524|#define is_minor_gc(gc) (is_generational(gc) && !(gc)->full)
  |  |  ------------------
  |  |  |  |  357|  1.04k|#define is_generational(gc) ((gc)->generational)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (357:29): [True: 185, False: 339]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (359:49): [True: 98, False: 87]
  |  |  ------------------
  ------------------
  |  Branch (1166:11): [True: 524, False: 35.5k]
  ------------------
 1167|     98|        page->old = TRUE;
  ------------------
  |  |   54|     98|#  define TRUE 1
  ------------------
 1168|  35.9k|      else
 1169|  35.9k|        page->old = FALSE;
  ------------------
  |  |   51|  35.9k|#  define FALSE 0
  ------------------
 1170|  36.0k|      page = page->next;
 1171|  36.0k|    }
 1172|  36.5k|    tried_sweep += MRB_HEAP_PAGE_SIZE;
  ------------------
  |  |  148|  36.5k|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
 1173|  36.5k|    gc->live -= freed;
 1174|  36.5k|    gc->live_after_mark -= freed;
 1175|  36.5k|  }
 1176|  68.1k|  gc->sweeps = page;
 1177|  68.1k|  return tried_sweep;
 1178|  68.1k|}
gc.c:unlink_heap_page:
  301|    523|{
  302|    523|  if (page->prev)
  ------------------
  |  Branch (302:7): [True: 77, False: 446]
  ------------------
  303|     77|    page->prev->next = page->next;
  304|    523|  if (page->next)
  ------------------
  |  Branch (304:7): [True: 523, False: 0]
  ------------------
  305|    523|    page->next->prev = page->prev;
  306|    523|  if (gc->heaps == page)
  ------------------
  |  Branch (306:7): [True: 446, False: 77]
  ------------------
  307|    446|    gc->heaps = page->next;
  308|    523|  page->prev = NULL;
  309|    523|  page->next = NULL;
  310|    523|}
gc.c:incremental_gc_step:
 1222|  1.90k|{
 1223|  1.90k|  size_t limit = 0, result = 0;
 1224|  1.90k|  limit = (GC_STEP_SIZE/100) * gc->step_ratio;
  ------------------
  |  |  151|  1.90k|#define GC_STEP_SIZE 1024
  ------------------
 1225|  9.22k|  while (result < limit) {
  ------------------
  |  Branch (1225:10): [True: 9.08k, False: 141]
  ------------------
 1226|  9.08k|    result += incremental_gc(mrb, gc, limit);
 1227|  9.08k|    if (gc->state == MRB_GC_STATE_ROOT)
  ------------------
  |  Branch (1227:9): [True: 1.76k, False: 7.31k]
  ------------------
 1228|  1.76k|      break;
 1229|  9.08k|  }
 1230|       |
 1231|  1.90k|  gc->threshold = gc->live + GC_STEP_SIZE;
  ------------------
  |  |  151|  1.90k|#define GC_STEP_SIZE 1024
  ------------------
 1232|  1.90k|}
gc.c:clear_all_old:
 1236|  16.0k|{
 1237|  16.0k|  mrb_assert(is_generational(gc));
  ------------------
  |  |   68|  16.0k|#define mrb_assert(p) ((void)0)
  ------------------
 1238|  16.0k|  if (gc->full) {
  ------------------
  |  Branch (1238:7): [True: 223, False: 15.8k]
  ------------------
 1239|       |    /* finish the half baked GC */
 1240|    223|    incremental_gc_finish(mrb, gc);
 1241|    223|  }
 1242|  15.8k|  else {
 1243|       |    /* Sweep the dead objects, then reset all the live objects
 1244|       |     * (including all the old objects, of course) to white. */
 1245|  15.8k|    gc->generational = FALSE;
  ------------------
  |  |   51|  15.8k|#  define FALSE 0
  ------------------
 1246|  15.8k|    prepare_incremental_sweep(mrb, gc);
 1247|  15.8k|    incremental_gc_finish(mrb, gc);
 1248|  15.8k|    gc->generational = TRUE;
  ------------------
  |  |   54|  15.8k|#  define TRUE 1
  ------------------
 1249|  15.8k|  }
 1250|       |  /* The gray objects have already been painted as white */
 1251|  16.0k|  gc->atomic_gray_list = gc->gray_list = NULL;
 1252|  16.0k|}
gc.c:gc_each_objects:
 1568|  15.6k|{
 1569|  15.6k|  mrb_heap_page* page;
 1570|       |
 1571|  15.6k|  page = gc->heaps;
 1572|  31.5k|  while (page != NULL) {
  ------------------
  |  Branch (1572:10): [True: 15.9k, False: 15.6k]
  ------------------
 1573|  15.9k|    RVALUE *p;
 1574|  15.9k|    int i;
 1575|       |
 1576|  15.9k|    p = objects(page);
  ------------------
  |  |  179|  15.9k|#define objects(p) ((RVALUE*)&p[1])
  ------------------
 1577|  16.3M|    for (i=0; i < MRB_HEAP_PAGE_SIZE; i++) {
  ------------------
  |  |  148|  16.3M|#define MRB_HEAP_PAGE_SIZE 1024
  ------------------
  |  Branch (1577:15): [True: 16.3M, False: 15.9k]
  ------------------
 1578|  16.3M|      if ((*callback)(mrb, &p[i].as.basic, data) == MRB_EACH_OBJ_BREAK)
  ------------------
  |  |   21|  16.3M|#define MRB_EACH_OBJ_BREAK 1
  ------------------
  |  Branch (1578:11): [True: 0, False: 16.3M]
  ------------------
 1579|      0|        return;
 1580|  16.3M|    }
 1581|  15.9k|    page = page->next;
 1582|  15.9k|  }
 1583|  15.6k|}

mrb_gc_mark_hash:
 1077|  17.4k|{
 1078|  17.4k|  h_each(h, entry, {
  ------------------
  |  |  209|  17.4k|#define h_each(h, entry_var, code) do {                                       \
  |  |  210|  17.4k|  struct RHash *h__ = h;                                                      \
  |  |  211|  17.4k|  hash_entry *h_e_ea__;                                                       \
  |  |  212|  17.4k|  uint32_t h_e_size__;                                                        \
  |  |  213|  17.4k|  h_ar_p(h) ? (h_e_ea__ = ar_ea(h__), h_e_size__ = ar_size(h__)) :            \
  |  |  ------------------
  |  |  |  |  286|  17.4k|#define h_ar_p(h) (!h_ht_p(h))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (286:19): [True: 17.2k, False: 279]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  214|  17.4k|              (h_e_ea__ = ht_ea(h__), h_e_size__ = ht_size(h__));             \
  |  |  215|  17.4k|  ea_each(h_e_ea__, h_e_size__, entry_var, code);                             \
  |  |  ------------------
  |  |  |  |  178|  17.4k|#define ea_each(ea, size, entry_var, code) do {                               \
  |  |  |  |  179|  17.4k|  hash_entry *entry_var = ea;                                                 \
  |  |  |  |  180|  17.4k|  uint32_t size__ = size;                                                     \
  |  |  |  |  181|  40.6k|  for (; 0 < size__; entry_var++) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:10): [True: 23.1k, False: 17.4k]
  |  |  |  |  ------------------
  |  |  |  |  182|  23.1k|    if (entry_deleted_p(entry_var)) continue;                                 \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (182:9): [True: 0, False: 23.1k]
  |  |  |  |  ------------------
  |  |  |  |  183|  23.1k|    --size__;                                                                 \
  |  |  |  |  184|   190k|    code;                                                                     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (184:5): [True: 21.6k, False: 1.43k]
  |  |  |  |  |  Branch (184:5): [True: 0, False: 1.43k]
  |  |  |  |  |  Branch (184:5): [Folded - Ignored]
  |  |  |  |  |  Branch (184:5): [True: 21.6k, False: 1.43k]
  |  |  |  |  |  Branch (184:5): [True: 0, False: 1.43k]
  |  |  |  |  |  Branch (184:5): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |  185|  23.1k|  }                                                                           \
  |  |  |  |  186|  17.4k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (186:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  216|  17.4k|} while (0)
  |  |  ------------------
  |  |  |  Branch (216:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1079|  17.4k|    mrb_gc_mark_value(mrb, entry->key);
 1080|  17.4k|    mrb_gc_mark_value(mrb, entry->val);
 1081|  17.4k|  });
 1082|  17.4k|}
mrb_gc_mark_hash_size:
 1086|  17.4k|{
 1087|  17.4k|  return h_size(h) * 2;
 1088|  17.4k|}
mrb_gc_free_hash:
 1092|  58.8k|{
 1093|  58.8k|  h_free_table(mrb, h);
 1094|  58.8k|}
mrb_hash_new:
 1118|  56.0k|{
 1119|  56.0k|  struct RHash *h = h_alloc(mrb);
 1120|  56.0k|  return mrb_obj_value(h);
 1121|  56.0k|}
mrb_hash_new_capa:
 1129|  45.9k|{
 1130|  45.9k|  if (capa < 0 || EA_MAX_CAPA < capa) {
  ------------------
  |  |   60|  45.9k|#define EA_MAX_CAPA U32(lesser(IB_MAX_CAPA - EA_N_RESERVED_INDICES, MRB_INT_MAX))
  |  |  ------------------
  |  |  |  |  285|  91.9k|#define U32(v) ((uint32_t)(v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:28): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1130:7): [True: 0, False: 45.9k]
  |  Branch (1130:19): [True: 0, False: 45.9k]
  ------------------
 1131|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "hash too big");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1132|      0|    return mrb_nil_value();  /* not reached */
 1133|      0|  }
 1134|  45.9k|  else if (capa == 0) {
  ------------------
  |  Branch (1134:12): [True: 43.2k, False: 2.77k]
  ------------------
 1135|  43.2k|    return mrb_hash_new(mrb);
 1136|  43.2k|  }
 1137|  2.77k|  else {
 1138|  2.77k|    uint32_t size = U32(capa);
  ------------------
  |  |  285|  2.77k|#define U32(v) ((uint32_t)(v))
  ------------------
 1139|  2.77k|    struct RHash *h = h_alloc(mrb);
 1140|  2.77k|    hash_entry *ea = ea_resize(mrb, NULL, size);
 1141|  2.77k|    if (size <= AR_MAX_SIZE) {
  ------------------
  |  |   70|  2.77k|#define AR_MAX_SIZE 16
  ------------------
  |  Branch (1141:9): [True: 2.16k, False: 615]
  ------------------
 1142|  2.16k|      ar_init(h, 0, ea, size, 0);
 1143|  2.16k|    }
 1144|    615|    else {
 1145|    615|      ht_init(mrb, h, 0, ea, size, NULL, ib_bit_for(size));
 1146|    615|    }
 1147|  2.77k|    return mrb_obj_value(h);
 1148|  2.77k|  }
 1149|  45.9k|}
mrb_hash_set:
 1243|   343k|{
 1244|   343k|  hash_modify(mrb, hash);
 1245|   343k|  key = h_key_for(mrb, key);
 1246|   343k|  h_set(mrb, mrb_hash_ptr(hash), key, val);
  ------------------
  |  |   35|   343k|#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   343k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1247|   343k|  mrb_field_write_barrier_value(mrb, mrb_basic_ptr(hash), key);
  ------------------
  |  | 1317|   343k|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|   343k|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|   343k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   686k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 222k, False: 120k]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 120k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|   120k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|   120k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|   343k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1248|   343k|  mrb_field_write_barrier_value(mrb, mrb_basic_ptr(hash), val);
  ------------------
  |  | 1317|   343k|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|   343k|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|   343k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   686k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 222k, False: 120k]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 120k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|   120k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|   120k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|   343k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1249|   343k|}
mrb_hash_clear:
 1535|  2.77k|{
 1536|  2.77k|  hash_modify(mrb, hash);
 1537|  2.77k|  h_clear(mrb, mrb_hash_ptr(hash));
  ------------------
  |  |   35|  2.77k|#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  2.77k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1538|  2.77k|  return hash;
 1539|  2.77k|}
mrb_hash_size:
 1572|  16.6k|{
 1573|  16.6k|  return (mrb_int)h_size(mrb_hash_ptr(hash));
  ------------------
  |  |   35|  16.6k|#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  16.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1574|  16.6k|}
mrb_hash_empty_p:
 1599|  17.3k|{
 1600|  17.3k|  return h_size(mrb_hash_ptr(self)) == 0;
  ------------------
  |  |   35|  17.3k|#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  17.3k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1601|  17.3k|}
mrb_init_hash:
 1818|  1.74k|{
 1819|  1.74k|  struct RClass *h;
 1820|       |
 1821|  1.74k|  mrb->hash_class = h = mrb_define_class(mrb, "Hash", mrb->object_class);              /* 15.2.13 */
 1822|  1.74k|  MRB_SET_INSTANCE_TT(h, MRB_TT_HASH);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 1823|       |
 1824|  1.74k|  mrb_define_method(mrb, h, "[]",              mrb_hash_aget,        MRB_ARGS_REQ(1)); /* 15.2.13.4.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1825|  1.74k|  mrb_define_method(mrb, h, "[]=",             mrb_hash_aset,        MRB_ARGS_REQ(2)); /* 15.2.13.4.3  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1826|  1.74k|  mrb_define_method(mrb, h, "clear",           mrb_hash_clear,       MRB_ARGS_NONE()); /* 15.2.13.4.4  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1827|  1.74k|  mrb_define_method(mrb, h, "default",         mrb_hash_default,     MRB_ARGS_OPT(1)); /* 15.2.13.4.5  */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 1828|  1.74k|  mrb_define_method(mrb, h, "default=",        mrb_hash_set_default, MRB_ARGS_REQ(1)); /* 15.2.13.4.6  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1829|  1.74k|  mrb_define_method(mrb, h, "default_proc",    mrb_hash_default_proc,MRB_ARGS_NONE()); /* 15.2.13.4.7  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1830|  1.74k|  mrb_define_method(mrb, h, "default_proc=",   mrb_hash_set_default_proc,MRB_ARGS_REQ(1)); /* 15.2.13.4.7  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1831|  1.74k|  mrb_define_method(mrb, h, "__delete",        mrb_hash_delete,      MRB_ARGS_REQ(1)); /* core of 15.2.13.4.8  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1832|  1.74k|  mrb_define_method(mrb, h, "empty?",          mrb_hash_empty_m,     MRB_ARGS_NONE()); /* 15.2.13.4.12 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1833|  1.74k|  mrb_define_method(mrb, h, "has_key?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.13 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1834|  1.74k|  mrb_define_method(mrb, h, "has_value?",      mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.14 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1835|  1.74k|  mrb_define_method(mrb, h, "include?",        mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.15 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1836|  1.74k|  mrb_define_method(mrb, h, "initialize",      mrb_hash_init,        MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); /* 15.2.13.4.16 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
                mrb_define_method(mrb, h, "initialize",      mrb_hash_init,        MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); /* 15.2.13.4.16 */
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
 1837|  1.74k|  mrb_define_method(mrb, h, "initialize_copy", mrb_hash_init_copy,   MRB_ARGS_REQ(1)); /* 15.2.13.4.17 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1838|  1.74k|  mrb_define_method(mrb, h, "key?",            mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.18 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1839|  1.74k|  mrb_define_method(mrb, h, "keys",            mrb_hash_keys,        MRB_ARGS_NONE()); /* 15.2.13.4.19 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1840|  1.74k|  mrb_define_method(mrb, h, "length",          mrb_hash_size_m,      MRB_ARGS_NONE()); /* 15.2.13.4.20 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1841|  1.74k|  mrb_define_method(mrb, h, "member?",         mrb_hash_has_key,     MRB_ARGS_REQ(1)); /* 15.2.13.4.21 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1842|  1.74k|  mrb_define_method(mrb, h, "replace",         mrb_hash_init_copy,   MRB_ARGS_REQ(1)); /* 15.2.13.4.23 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1843|  1.74k|  mrb_define_method(mrb, h, "shift",           mrb_hash_shift,       MRB_ARGS_NONE()); /* 15.2.13.4.24 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1844|  1.74k|  mrb_define_method(mrb, h, "size",            mrb_hash_size_m,      MRB_ARGS_NONE()); /* 15.2.13.4.25 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1845|  1.74k|  mrb_define_method(mrb, h, "store",           mrb_hash_aset,        MRB_ARGS_REQ(2)); /* 15.2.13.4.26 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1846|  1.74k|  mrb_define_method(mrb, h, "value?",          mrb_hash_has_value,   MRB_ARGS_REQ(1)); /* 15.2.13.4.27 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1847|  1.74k|  mrb_define_method(mrb, h, "values",          mrb_hash_values,      MRB_ARGS_NONE()); /* 15.2.13.4.28 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1848|  1.74k|  mrb_define_method(mrb, h, "rehash",          mrb_hash_rehash,      MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1849|  1.74k|  mrb_define_method(mrb, h, "__merge",         mrb_hash_merge_m,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 1850|  1.74k|  mrb_define_method(mrb, h, "__compact",       mrb_hash_compact,     MRB_ARGS_NONE()); /* implementation of Hash#compact! */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 1851|  1.74k|}
hash.c:h_ht_p:
  143|   422k|  MRB_INLINE mrb_bool h_##n_##_p(const struct RHash *h) {                     \
  144|   422k|    return (h->flags & MRB_HASH_##k_) == MRB_HASH_##k_;                       \
  145|   422k|  }
hash.c:ar_ea:
  110|   575k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ar_size:
  110|   243k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ht_ea:
  110|   249k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ht_size:
  110|   134k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:entry_deleted_p:
  387|  1.50M|{
  388|  1.50M|  return mrb_undef_p(entry->key);
  ------------------
  |  |  173|  1.50M|#define mrb_undef_p(o) ((o).w == MRB_Qundef)
  ------------------
  389|  1.50M|}
hash.c:h_size:
  110|  51.4k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:h_free_table:
  993|  61.6k|{
  994|  61.6k|  (h_ar_p(h) ? ar_free : ht_free)(mrb, h);
  ------------------
  |  |  286|  61.6k|#define h_ar_p(h) (!h_ht_p(h))
  |  |  ------------------
  |  |  |  Branch (286:19): [True: 60.1k, False: 1.50k]
  |  |  ------------------
  ------------------
  995|  61.6k|}
hash.c:ar_free:
  489|  60.1k|{
  490|  60.1k|  mrb_free(mrb, ar_ea(h));
  491|  60.1k|}
hash.c:ht_free:
  799|  1.50k|{
  800|  1.50k|  mrb_free(mrb, ht_ea(h));
  801|  1.50k|  mrb_free(mrb, h_ht(h));
  802|  1.50k|}
hash.c:h_ht:
  110|  1.64k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ar_ea_capa:
  110|   225k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ht_ea_capa:
  110|  16.3k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ib_byte_size_for:
  758|  1.64k|{
  759|  1.64k|  mrb_assert(IB_INIT_BIT <= ib_bit);
  ------------------
  |  |   68|  1.64k|#define mrb_assert(p) ((void)0)
  ------------------
  760|  1.64k|  uint32_t ary_size = IB_INIT_BIT == 4 ?
  ------------------
  |  |   63|  1.64k|#define IB_INIT_BIT (                                                         \
  |  |   64|  1.64k|  ib_upper_bound_for(32) <= AR_MAX_SIZE ? 6 :                                 \
  |  |  ------------------
  |  |  |  |   70|  1.64k|#define AR_MAX_SIZE 16
  |  |  ------------------
  |  |  |  Branch (64:3): [True: 0, False: 1.64k]
  |  |  ------------------
  |  |   65|  1.64k|  ib_upper_bound_for(16) <= AR_MAX_SIZE ? 5 :                                 \
  |  |  ------------------
  |  |  |  |   70|  1.64k|#define AR_MAX_SIZE 16
  |  |  ------------------
  |  |  |  Branch (65:3): [True: 1.64k, False: 0]
  |  |  ------------------
  |  |   66|  1.64k|  4                                                                           \
  |  |   67|  1.64k|)
  ------------------
  |  Branch (760:23): [True: 0, False: 1.64k]
  ------------------
  761|      0|    ib_bit_to_capa(ib_bit) * 2 / IB_TYPE_BIT * ib_bit / 2 :
  ------------------
  |  |   62|      0|#define IB_TYPE_BIT 32
  ------------------
  762|  1.64k|    ib_bit_to_capa(ib_bit) / IB_TYPE_BIT * ib_bit;
  ------------------
  |  |   62|  1.64k|#define IB_TYPE_BIT 32
  ------------------
  763|  1.64k|  return U32(sizeof(uint32_t) * ary_size);
  ------------------
  |  |  285|  1.64k|#define U32(v) ((uint32_t)(v))
  ------------------
  764|  1.64k|}
hash.c:ib_upper_bound_for:
  744|   123k|{
  745|   123k|  return (capa >> 2) | (capa >> 1);  /* 3/4 */
  746|   123k|}
hash.c:ib_bit_to_capa:
  738|   260k|{
  739|   260k|  return U32(1) << bit;
  ------------------
  |  |  285|   260k|#define U32(v) ((uint32_t)(v))
  ------------------
  740|   260k|}
hash.c:ib_bit:
  117|   259k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {                            \
  118|   259k|    return (t_)((h->flags & MRB_HASH_##k_##_MASK) >> MRB_HASH_##k_##_SHIFT);  \
  119|   259k|  }
hash.c:h_alloc:
  981|  58.8k|{
  982|  58.8k|  return MRB_OBJ_ALLOC(mrb, MRB_TT_HASH, mrb->hash_class);
  ------------------
  |  | 1200|  58.8k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
  983|  58.8k|}
hash.c:ea_resize:
  418|  50.8k|{
  419|  50.8k|  return (hash_entry*)mrb_realloc(mrb, ea, sizeof(hash_entry) * capa);
  420|  50.8k|}
hash.c:ar_init:
  479|  4.93k|{
  480|  4.93k|  h_ar_on(h);
  ------------------
  |  |  287|  4.93k|#define h_ar_on(h) h_ht_off(h)
  ------------------
  481|  4.93k|  ar_set_size(h, size);
  482|  4.93k|  ar_set_ea(h, ea);
  483|  4.93k|  ar_set_ea_capa(h, ea_capa);
  484|  4.93k|  ar_set_ea_n_used(h, ea_n_used);
  485|  4.93k|}
hash.c:h_ht_off:
  140|  4.93k|  MRB_INLINE void h_##n_##_off(struct RHash *h) {                             \
  141|  4.93k|    h->flags &= ~MRB_HASH_##k_;                                               \
  142|  4.93k|  }                                                                           \
hash.c:ar_set_size:
  112|   229k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ar_set_ea:
  112|  51.8k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ar_set_ea_capa:
  112|  51.8k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ar_set_ea_n_used:
  112|   229k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ht_init:
  784|  1.64k|{
  785|  1.64k|  size_t ib_byte_size = ib_byte_size_for(ib_bit);
  786|  1.64k|  size_t ht_byte_size = sizeof(hash_table) + ib_byte_size;
  787|  1.64k|  ht = (hash_table*)mrb_realloc(mrb, ht, ht_byte_size);
  788|  1.64k|  h_ht_on(h);
  789|  1.64k|  h_set_ht(h, ht);
  790|  1.64k|  ht_set_size(h, size);
  791|  1.64k|  ht_set_ea(h, ea);
  792|  1.64k|  ht_set_ea_capa(h, ea_capa);
  793|  1.64k|  ht_set_ea_n_used(h, size);
  794|  1.64k|  ib_init(mrb, h, ib_bit, ib_byte_size);
  795|  1.64k|}
hash.c:h_ht_on:
  137|  1.64k|  MRB_INLINE void h_##n_##_on(struct RHash *h) {                              \
  138|  1.64k|    h->flags |= MRB_HASH_##k_;                                                \
  139|  1.64k|  }                                                                           \
hash.c:h_set_ht:
  112|  1.64k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ht_set_size:
  112|  17.8k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ht_set_ea:
  112|  2.83k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ht_set_ea_capa:
  112|  2.83k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ht_set_ea_n_used:
  112|  17.8k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
hash.c:ib_init:
  768|  1.64k|{
  769|  1.64k|  hash_entry *ea = ht_ea(h);
  770|  1.64k|  memset(ht_ib(h), 0xff, ib_byte_size);
  771|  1.64k|  ib_set_bit(h, ib_bit);
  772|  1.64k|  ea_each_used(ea, ht_ea_n_used(h), entry, {
  ------------------
  |  |  171|  1.64k|#define ea_each_used(ea, n_used, entry_var, code) do {                        \
  |  |  172|  1.64k|  hash_entry *entry_var = ea, *ea_end__ = entry_var + (n_used);               \
  |  |  173|  24.3k|  for (; entry_var < ea_end__; entry_var++) {                                 \
  |  |  ------------------
  |  |  |  Branch (173:10): [True: 22.7k, False: 1.64k]
  |  |  ------------------
  |  |  174|   440k|    code;                                                                     \
  |  |  ------------------
  |  |  |  Branch (174:5): [True: 109k, False: 22.7k]
  |  |  |  Branch (174:5): [Folded - Ignored]
  |  |  ------------------
  |  |  175|  22.7k|  }                                                                           \
  |  |  176|  1.64k|} while (0)
  |  |  ------------------
  |  |  |  Branch (176:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  773|  1.64k|    ib_cycle_by_key(mrb, h, entry->key, it, {
  774|  1.64k|      if (!ib_it_empty_p(it)) continue;
  775|  1.64k|      ib_it_set(it, U32(entry - ea));
  776|  1.64k|      break;
  777|  1.64k|    });
  778|  1.64k|  });
  779|  1.64k|}
hash.c:ht_ib:
  110|   383k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ib_set_bit:
  121|  1.64k|  MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {                      \
  122|  1.64k|    h->flags &= ~MRB_HASH_##k_##_MASK;                                        \
  123|  1.64k|    h->flags |= v << MRB_HASH_##k_##_SHIFT;                                   \
  124|  1.64k|  }
hash.c:ht_ea_n_used:
  110|   136k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:ib_it_init:
  641|   140k|{
  642|   140k|  it->h = h;
  643|   140k|  it->bit = ib_bit(h);
  644|   140k|  it->mask = ib_bit_to_capa(it->bit) - 1;
  645|   140k|  it->pos = ib_it_pos_for(it, obj_hash_code(mrb, key, h));
  646|   140k|  it->step = 0;
  647|   140k|}
hash.c:ib_it_pos_for:
  605|   415k|{
  606|   415k|  return v & it->mask;
  607|   415k|}
hash.c:obj_hash_code:
  320|   140k|{
  321|   140k|  enum mrb_vtype tt = mrb_type(key);
  322|   140k|  uint32_t hash_code;
  323|   140k|  mrb_value hash_code_obj;
  324|   140k|  switch (tt) {
  325|   125k|  case MRB_TT_STRING:
  ------------------
  |  Branch (325:3): [True: 125k, False: 15.1k]
  ------------------
  326|   125k|    hash_code = mrb_str_hash(mrb, key);
  327|   125k|    break;
  328|      0|  case MRB_TT_TRUE:
  ------------------
  |  Branch (328:3): [True: 0, False: 140k]
  ------------------
  329|      0|  case MRB_TT_FALSE:
  ------------------
  |  Branch (329:3): [True: 0, False: 140k]
  ------------------
  330|  15.1k|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (330:3): [True: 15.1k, False: 125k]
  ------------------
  331|  15.1k|    hash_code = U32(mrb_fixnum(key));
  ------------------
  |  |  285|  15.1k|#define U32(v) ((uint32_t)(v))
  ------------------
  332|  15.1k|    break;
  333|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (333:3): [True: 0, False: 140k]
  ------------------
  334|      0|    if (mrb_fixnum_p(key)) {
  ------------------
  |  |  170|      0|#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  335|      0|      hash_code = U32(mrb_fixnum(key));
  ------------------
  |  |  285|      0|#define U32(v) ((uint32_t)(v))
  ------------------
  336|      0|      break;
  337|      0|    }
  338|      0|#ifndef MRB_NO_FLOAT
  339|       |    /* fall through */
  340|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (340:3): [True: 0, False: 140k]
  ------------------
  341|      0|#endif
  342|      0|    hash_code = U32(mrb_obj_id(key));
  ------------------
  |  |  285|      0|#define U32(v) ((uint32_t)(v))
  ------------------
  343|      0|    break;
  344|      0|  default:
  ------------------
  |  Branch (344:3): [True: 0, False: 140k]
  ------------------
  345|      0|    h_check_modified(mrb, h, {
  ------------------
  |  |  261|      0|#define h_check_modified(mrb, h, code) do {                                     \
  |  |  262|      0|  struct RHash *h__ = h;                                                        \
  |  |  263|      0|  uint32_t mask__ = MRB_HASH_HT|MRB_HASH_IB_BIT_MASK|MRB_HASH_AR_EA_CAPA_MASK;  \
  |  |  ------------------
  |  |  |  |  224|      0|#define MRB_HASH_HT                 (1 << (MRB_HASH_SIZE_FLAGS_SHIFT + 2))
  |  |  |  |  ------------------
  |  |  |  |  |  |  218|      0|#define MRB_HASH_SIZE_FLAGS_SHIFT   (MRB_HASH_AR_EA_CAPA_BIT * 2)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define MRB_HASH_AR_EA_CAPA_BIT     5
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 uint32_t mask__ = MRB_HASH_HT|MRB_HASH_IB_BIT_MASK|MRB_HASH_AR_EA_CAPA_MASK;  \
  |  |  ------------------
  |  |  |  |  219|      0|#define MRB_HASH_IB_BIT_MASK        ((1 << MRB_HASH_IB_BIT_BIT) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  213|      0|#define MRB_HASH_IB_BIT_BIT         5
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 uint32_t mask__ = MRB_HASH_HT|MRB_HASH_IB_BIT_MASK|MRB_HASH_AR_EA_CAPA_MASK;  \
  |  |  ------------------
  |  |  |  |  220|      0|#define MRB_HASH_AR_EA_CAPA_MASK    ((1 << MRB_HASH_AR_EA_CAPA_BIT) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|      0|#define MRB_HASH_AR_EA_CAPA_BIT     5
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  264|      0|  uint32_t flags__ = h__->flags & mask__;                                       \
  |  |  265|      0|  void* tbl__ = (mrb_assert(h__->hsh.ht), h__->hsh.ht);                         \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |  266|      0|  uint32_t ht_ea_capa__ = 0;                                                    \
  |  |  267|      0|  hash_entry *ht_ea__ = NULL;                                                   \
  |  |  268|      0|  if (H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR || h_ht_p(h__)) {                  \
  |  |  ------------------
  |  |  |  |  233|      0|# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (268:49): [True: 0, False: 0]
  |  |  ------------------
  |  |  269|      0|    ht_ea_capa__ = ht_ea_capa(h__);                                             \
  |  |  270|      0|  }                                                                             \
  |  |  271|      0|  if (H_CHECK_MODIFIED_USE_HT_EA_FOR_AR || h_ht_p(h__)) {                       \
  |  |  ------------------
  |  |  |  |  232|      0|# define H_CHECK_MODIFIED_USE_HT_EA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  |  |  272|      0|    ht_ea__ = ht_ea(h__);                                                       \
  |  |  273|      0|  }                                                                             \
  |  |  274|      0|  code;                                                                         \
  |  |  275|      0|  if (flags__ != (h__->flags & mask__) ||                                       \
  |  |  ------------------
  |  |  |  Branch (275:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  276|      0|      tbl__ != h__->hsh.ht ||                                                       \
  |  |  ------------------
  |  |  |  Branch (276:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  277|      0|      ((H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR || h_ht_p(h__)) &&               \
  |  |  ------------------
  |  |  |  |  233|      0|# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (277:51): [True: 0, False: 0]
  |  |  ------------------
  |  |  278|      0|       ht_ea_capa__ != ht_ea_capa(h__)) ||                                      \
  |  |  ------------------
  |  |  |  Branch (278:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  279|      0|      ((H_CHECK_MODIFIED_USE_HT_EA_FOR_AR || h_ht_p(h__)) &&                    \
  |  |  ------------------
  |  |  |  |  232|      0|# define H_CHECK_MODIFIED_USE_HT_EA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (279:46): [True: 0, False: 0]
  |  |  ------------------
  |  |  280|      0|       ht_ea__ != ht_ea(h__))) {                                                \
  |  |  ------------------
  |  |  |  Branch (280:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  281|      0|    mrb_raise(mrb, E_RUNTIME_ERROR, "hash modified");                           \
  |  |  ------------------
  |  |  |  | 1374|      0|#define E_RUNTIME_ERROR      mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError))
  |  |  |  |  ------------------
  |  |  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  282|      0|  }                                                                             \
  |  |  283|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (283:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  346|      0|      hash_code_obj = mrb_funcall_argv(mrb, key, MRB_SYM(hash), 0, NULL);
  347|      0|    });
  348|       |
  349|      0|    hash_code = U32(tt) ^ U32(mrb_integer(hash_code_obj));
  ------------------
  |  |  285|      0|#define U32(v) ((uint32_t)(v))
  ------------------
                  hash_code = U32(tt) ^ U32(mrb_integer(hash_code_obj));
  ------------------
  |  |  285|      0|#define U32(v) ((uint32_t)(v))
  ------------------
  350|      0|    break;
  351|   140k|  }
  352|   140k|  return hash_code ^ (hash_code << 2) ^ (hash_code >> 2);
  353|   140k|}
hash.c:ib_it_next:
  651|   274k|{
  652|       |  /*
  653|       |   * [IB image]
  654|       |   *
  655|       |   *                  ary_index(1) --.
  656|       |   *                                  \          .-- shift1(3)  .-- shift2(29)
  657|       |   *                     pos(6) --.    \        /              /
  658|       |   *  View    |                    \    \    <-o-> <----------o---------->
  659|       |   * -------- +---------------------\----\--+-----------------------------+-----
  660|       |   *  array   |               0      `--. `-|--- o          1             | ...
  661|       |   *          +---------+---------+-----+\--+-----+---------+---------+---+-----
  662|       |   *  buckets |    0    |    1    | ... | o  6    |    7    |    8    |     ...
  663|       |   *          +---------+---------+-----+=========+---------+---------+---------
  664|       |   *  bit set |1 1 1 0 0|0 0 0 1 1| ... |0 1 0 1 1|0 1 1 1 0|0 1 0 1 0|     ...
  665|       |   *          +---------+---------+-----+========*+---------+---------+---------
  666|       |   *           <---o--->                          \
  667|       |   *                \                              `-- bit_pos(34)
  668|       |   *                 `-- bit(5)
  669|       |   */
  670|       |
  671|       |  /* Slide to handle as `capa == 32` to avoid 64-bit operations */
  672|   274k|  uint32_t slid_pos = it->pos & (IB_TYPE_BIT - 1);
  ------------------
  |  |   62|   274k|#define IB_TYPE_BIT 32
  ------------------
  673|   274k|  uint32_t slid_bit_pos = it->bit * (slid_pos + 1) - 1;
  674|   274k|  uint32_t slid_ary_index = slid_bit_pos / IB_TYPE_BIT;
  ------------------
  |  |   62|   274k|#define IB_TYPE_BIT 32
  ------------------
  675|   274k|  it->ary_index = slid_ary_index + it->pos / IB_TYPE_BIT * it->bit;
  ------------------
  |  |   62|   274k|#define IB_TYPE_BIT 32
  ------------------
  676|   274k|  it->shift2 = (slid_ary_index + 1) * IB_TYPE_BIT - slid_bit_pos - 1;
  ------------------
  |  |   62|   274k|#define IB_TYPE_BIT 32
  ------------------
  677|   274k|  it->ea_index = (ht_ib(it->h)[it->ary_index] >> it->shift2) & it->mask;
  678|   274k|  if (IB_TYPE_BIT - it->bit < it->shift2) {
  ------------------
  |  |   62|   274k|#define IB_TYPE_BIT 32
  ------------------
  |  Branch (678:7): [True: 19.4k, False: 254k]
  ------------------
  679|  19.4k|    it->shift1 = IB_TYPE_BIT - it->shift2;
  ------------------
  |  |   62|  19.4k|#define IB_TYPE_BIT 32
  ------------------
  680|  19.4k|    it->ea_index |= (ht_ib(it->h)[it->ary_index - 1] << it->shift1) & it->mask;
  681|  19.4k|  }
  682|   254k|  else {
  683|   254k|    it->shift1 = 0;
  684|   254k|  }
  685|   274k|  it->pos = ib_it_pos_for(it, it->pos + (++it->step));
  686|   274k|}
hash.c:ib_it_empty_p:
  623|   131k|{
  624|   131k|  return it->ea_index == ib_it_empty_value(it);
  625|   131k|}
hash.c:ib_it_empty_value:
  611|   131k|{
  612|   131k|  return it->mask;
  613|   131k|}
hash.c:ib_it_set:
  696|  38.9k|{
  697|  38.9k|  uint32_t mask, i;
  698|  38.9k|  it->ea_index = ea_index;
  699|  38.9k|  if (it->shift1) {
  ------------------
  |  Branch (699:7): [True: 4.89k, False: 34.0k]
  ------------------
  700|  4.89k|    i = it->ary_index - 1;
  701|  4.89k|    mask = it->mask >> it->shift1;
  702|  4.89k|    ht_ib(it->h)[i] = (ht_ib(it->h)[i] & ~mask) | (ea_index >> it->shift1);
  703|  4.89k|  }
  704|  38.9k|  i = it->ary_index;
  705|  38.9k|  mask = it->mask << it->shift2;
  706|  38.9k|  ht_ib(it->h)[i] = (ht_ib(it->h)[i] & ~mask) | (ea_index << it->shift2);
  707|  38.9k|}
hash.c:ib_bit_for:
  750|    615|{
  751|    615|  uint32_t capa = next_power2(size);
  752|    615|  if (capa != IB_MAX_CAPA && ib_upper_bound_for(capa) < size) capa *= 2;
  ------------------
  |  |   61|  1.23k|#define IB_MAX_CAPA (U32(1) << IB_MAX_BIT)
  |  |  ------------------
  |  |  |  |  285|    615|#define U32(v) ((uint32_t)(v))
  |  |  ------------------
  |  |               #define IB_MAX_CAPA (U32(1) << IB_MAX_BIT)
  |  |  ------------------
  |  |  |  |   68|    615|#define IB_MAX_BIT (IB_TYPE_BIT - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    615|#define IB_TYPE_BIT 32
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (752:7): [True: 615, False: 0]
  |  Branch (752:30): [True: 150, False: 465]
  ------------------
  753|    615|  return ib_capa_to_bit(capa);
  754|    615|}
hash.c:next_power2:
  303|    615|{
  304|    615|  mrb_assert(v != 0);
  ------------------
  |  |   68|    615|#define mrb_assert(p) ((void)0)
  ------------------
  305|    615|#ifdef __GNUC__
  306|    615|  return U32(1) << ((sizeof(unsigned) * CHAR_BIT) - __builtin_clz(v));
  ------------------
  |  |  285|    615|#define U32(v) ((uint32_t)(v))
  ------------------
  307|       |#else
  308|       |  v |= v >> 1;
  309|       |  v |= v >> 2;
  310|       |  v |= v >> 4;
  311|       |  v |= v >> 8;
  312|       |  v |= v >> 16;
  313|       |  v++;
  314|       |  return v;
  315|       |#endif
  316|    615|}
hash.c:ib_capa_to_bit:
  723|    615|{
  724|    615|#ifdef __GNUC__
  725|    615|  return U32(__builtin_ctz(capa));
  ------------------
  |  |  285|    615|#define U32(v) ((uint32_t)(v))
  ------------------
  726|       |#else
  727|       |  /* http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn */
  728|       |  static const uint32_t MultiplyDeBruijnBitPosition2[] = {
  729|       |    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
  730|       |    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
  731|       |  };
  732|       |  return MultiplyDeBruijnBitPosition2[U32(capa * 0x077CB531U) >> 27];
  733|       |#endif
  734|    615|}
hash.c:ar_ea_n_used:
  110|   225k|  MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
hash.c:obj_eql:
  357|  1.60M|{
  358|  1.60M|  enum mrb_vtype tt = mrb_type(a);
  359|  1.60M|  mrb_bool eql;
  360|       |
  361|  1.60M|  switch (tt) {
  362|   113k|  case MRB_TT_STRING:
  ------------------
  |  Branch (362:3): [True: 113k, False: 1.49M]
  ------------------
  363|   113k|    return mrb_str_equal(mrb, a, b);
  364|       |
  365|  1.49M|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (365:3): [True: 1.49M, False: 113k]
  ------------------
  366|  1.49M|    if (!mrb_symbol_p(b)) return FALSE;
  ------------------
  |  |  172|  1.49M|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|  1.49M|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
                  if (!mrb_symbol_p(b)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (366:9): [True: 0, False: 1.49M]
  ------------------
  367|  1.49M|    return mrb_symbol(a) == mrb_symbol(b);
  ------------------
  |  |  167|  1.49M|#define mrb_symbol(o)  (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT)
  |  |  ------------------
  |  |  |  |   63|  1.49M|#define WORDBOX_SYMBOL_SHIFT    32
  |  |  ------------------
  ------------------
                  return mrb_symbol(a) == mrb_symbol(b);
  ------------------
  |  |  167|  1.49M|#define mrb_symbol(o)  (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT)
  |  |  ------------------
  |  |  |  |   63|  1.49M|#define WORDBOX_SYMBOL_SHIFT    32
  |  |  ------------------
  ------------------
  368|       |
  369|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (369:3): [True: 0, False: 1.60M]
  ------------------
  370|      0|    if (!mrb_integer_p(b)) return FALSE;
  ------------------
  |  |  171|      0|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  if (!mrb_integer_p(b)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  371|      0|    return mrb_integer(a) == mrb_integer(b);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
                  return mrb_integer(a) == mrb_integer(b);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  372|       |
  373|      0|#ifndef MRB_NO_FLOAT
  374|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (374:3): [True: 0, False: 1.60M]
  ------------------
  375|      0|    if (!mrb_float_p(b)) return FALSE;
  ------------------
  |  |  179|      0|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
                  if (!mrb_float_p(b)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (375:9): [True: 0, False: 0]
  ------------------
  376|      0|    return mrb_float(a) == mrb_float(b);
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
                  return mrb_float(a) == mrb_float(b);
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  377|      0|#endif
  378|       |
  379|      0|  default:
  ------------------
  |  Branch (379:3): [True: 0, False: 1.60M]
  ------------------
  380|      0|    h_check_modified(mrb, h, {eql = mrb_eql(mrb, a, b);});
  ------------------
  |  |  261|      0|#define h_check_modified(mrb, h, code) do {                                     \
  |  |  262|      0|  struct RHash *h__ = h;                                                        \
  |  |  263|      0|  uint32_t mask__ = MRB_HASH_HT|MRB_HASH_IB_BIT_MASK|MRB_HASH_AR_EA_CAPA_MASK;  \
  |  |  ------------------
  |  |  |  |  224|      0|#define MRB_HASH_HT                 (1 << (MRB_HASH_SIZE_FLAGS_SHIFT + 2))
  |  |  |  |  ------------------
  |  |  |  |  |  |  218|      0|#define MRB_HASH_SIZE_FLAGS_SHIFT   (MRB_HASH_AR_EA_CAPA_BIT * 2)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define MRB_HASH_AR_EA_CAPA_BIT     5
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 uint32_t mask__ = MRB_HASH_HT|MRB_HASH_IB_BIT_MASK|MRB_HASH_AR_EA_CAPA_MASK;  \
  |  |  ------------------
  |  |  |  |  219|      0|#define MRB_HASH_IB_BIT_MASK        ((1 << MRB_HASH_IB_BIT_BIT) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  213|      0|#define MRB_HASH_IB_BIT_BIT         5
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 uint32_t mask__ = MRB_HASH_HT|MRB_HASH_IB_BIT_MASK|MRB_HASH_AR_EA_CAPA_MASK;  \
  |  |  ------------------
  |  |  |  |  220|      0|#define MRB_HASH_AR_EA_CAPA_MASK    ((1 << MRB_HASH_AR_EA_CAPA_BIT) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|      0|#define MRB_HASH_AR_EA_CAPA_BIT     5
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  264|      0|  uint32_t flags__ = h__->flags & mask__;                                       \
  |  |  265|      0|  void* tbl__ = (mrb_assert(h__->hsh.ht), h__->hsh.ht);                         \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |  266|      0|  uint32_t ht_ea_capa__ = 0;                                                    \
  |  |  267|      0|  hash_entry *ht_ea__ = NULL;                                                   \
  |  |  268|      0|  if (H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR || h_ht_p(h__)) {                  \
  |  |  ------------------
  |  |  |  |  233|      0|# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (268:49): [True: 0, False: 0]
  |  |  ------------------
  |  |  269|      0|    ht_ea_capa__ = ht_ea_capa(h__);                                             \
  |  |  270|      0|  }                                                                             \
  |  |  271|      0|  if (H_CHECK_MODIFIED_USE_HT_EA_FOR_AR || h_ht_p(h__)) {                       \
  |  |  ------------------
  |  |  |  |  232|      0|# define H_CHECK_MODIFIED_USE_HT_EA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  |  |  272|      0|    ht_ea__ = ht_ea(h__);                                                       \
  |  |  273|      0|  }                                                                             \
  |  |  274|      0|  code;                                                                         \
  |  |  275|      0|  if (flags__ != (h__->flags & mask__) ||                                       \
  |  |  ------------------
  |  |  |  Branch (275:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  276|      0|      tbl__ != h__->hsh.ht ||                                                       \
  |  |  ------------------
  |  |  |  Branch (276:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  277|      0|      ((H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR || h_ht_p(h__)) &&               \
  |  |  ------------------
  |  |  |  |  233|      0|# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (277:51): [True: 0, False: 0]
  |  |  ------------------
  |  |  278|      0|       ht_ea_capa__ != ht_ea_capa(h__)) ||                                      \
  |  |  ------------------
  |  |  |  Branch (278:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  279|      0|      ((H_CHECK_MODIFIED_USE_HT_EA_FOR_AR || h_ht_p(h__)) &&                    \
  |  |  ------------------
  |  |  |  |  232|      0|# define H_CHECK_MODIFIED_USE_HT_EA_FOR_AR TRUE
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#  define TRUE 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (54:16): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (279:46): [True: 0, False: 0]
  |  |  ------------------
  |  |  280|      0|       ht_ea__ != ht_ea(h__))) {                                                \
  |  |  ------------------
  |  |  |  Branch (280:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  281|      0|    mrb_raise(mrb, E_RUNTIME_ERROR, "hash modified");                           \
  |  |  ------------------
  |  |  |  | 1374|      0|#define E_RUNTIME_ERROR      mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError))
  |  |  |  |  ------------------
  |  |  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  282|      0|  }                                                                             \
  |  |  283|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (283:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  381|      0|    return eql;
  382|  1.60M|  }
  383|  1.60M|}
hash.c:ib_it_deleted_value:
  617|   142k|{
  618|   142k|  return it->mask - 1;
  619|   142k|}
hash.c:ib_it_entry:
  717|   228k|{
  718|   228k|  return ea_get(ht_ea(it->h), it->ea_index);
  719|   228k|}
hash.c:ea_get:
  465|   228k|{
  466|   228k|  return &ea[index];
  467|   228k|}
hash.c:hash_modify:
 1155|   346k|{
 1156|   346k|  mrb_check_frozen(mrb, mrb_hash_ptr(hash));
  ------------------
  |  |   35|   346k|#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   346k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1157|   346k|}
hash.c:h_key_for:
  971|   343k|{
  972|   343k|  if (mrb_string_p(key) && !MRB_FROZEN_P(mrb_str_ptr(key))) {
  ------------------
  |  |  187|   343k|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|   686k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|   686k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|   686k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 222k, False: 120k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 120k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 120k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (mrb_string_p(key) && !MRB_FROZEN_P(mrb_str_ptr(key))) {
  ------------------
  |  |   25|   120k|#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
  |  |  ------------------
  |  |  |  |   24|   120k|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  ------------------
  ------------------
  |  Branch (972:28): [True: 120k, False: 0]
  ------------------
  973|   120k|    key = mrb_str_dup(mrb, key);
  974|   120k|    MRB_SET_FROZEN_FLAG(mrb_str_ptr(key));
  ------------------
  |  |   26|   120k|#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
  |  |  ------------------
  |  |  |  |   24|   120k|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  ------------------
  ------------------
  975|   120k|  }
  976|   343k|  return key;
  977|   343k|}
hash.c:h_set:
 1012|   343k|{
 1013|   343k|  (h_ar_p(h) ? ar_set : ht_set)(mrb, h, key, val);
  ------------------
  |  |  286|   343k|#define h_ar_p(h) (!h_ht_p(h))
  |  |  ------------------
  |  |  |  Branch (286:19): [True: 226k, False: 117k]
  |  |  ------------------
  ------------------
 1014|   343k|}
hash.c:ar_set:
  524|   226k|{
  525|   226k|  uint32_t size = ar_size(h);
  526|   226k|  hash_entry *entry;
  527|   226k|  if ((entry = ea_get_by_key(mrb, ar_ea(h), size, key, h))) {
  ------------------
  |  Branch (527:7): [True: 838, False: 225k]
  ------------------
  528|    838|    entry->val = val;
  529|    838|  }
  530|   225k|  else {
  531|   225k|    uint32_t ea_capa = ar_ea_capa(h), ea_n_used = ar_ea_n_used(h);
  532|   225k|    if (ea_capa == ea_n_used) {
  ------------------
  |  Branch (532:9): [True: 47.7k, False: 177k]
  ------------------
  533|  47.7k|      if (size == ea_n_used) {
  ------------------
  |  Branch (533:11): [True: 47.7k, False: 0]
  ------------------
  534|  47.7k|        if (size == AR_MAX_SIZE) {
  ------------------
  |  |   70|  47.7k|#define AR_MAX_SIZE 16
  ------------------
  |  Branch (534:13): [True: 892, False: 46.8k]
  ------------------
  535|    892|          ht_init(mrb, h, size, ar_ea(h), ea_capa, NULL, IB_INIT_BIT);
  ------------------
  |  |   63|    892|#define IB_INIT_BIT (                                                         \
  |  |   64|    892|  ib_upper_bound_for(32) <= AR_MAX_SIZE ? 6 :                                 \
  |  |  ------------------
  |  |  |  |   70|    892|#define AR_MAX_SIZE 16
  |  |  ------------------
  |  |  |  Branch (64:3): [True: 0, False: 892]
  |  |  ------------------
  |  |   65|    892|  ib_upper_bound_for(16) <= AR_MAX_SIZE ? 5 :                                 \
  |  |  ------------------
  |  |  |  |   70|    892|#define AR_MAX_SIZE 16
  |  |  ------------------
  |  |  |  Branch (65:3): [True: 892, False: 0]
  |  |  ------------------
  |  |   66|    892|  4                                                                           \
  |  |   67|    892|)
  ------------------
  536|    892|          ht_set(mrb, h, key, val);
  537|    892|          return;
  538|    892|        }
  539|  46.8k|        else {
  540|  46.8k|          ar_adjust_ea(mrb, h, size, AR_MAX_SIZE);
  ------------------
  |  |   70|  46.8k|#define AR_MAX_SIZE 16
  ------------------
  541|  46.8k|        }
  542|  47.7k|      }
  543|      0|      else {
  544|      0|        ar_compress(mrb, h);
  545|      0|        ea_n_used = size;
  546|      0|      }
  547|  47.7k|    }
  548|   224k|    ea_set(ar_ea(h), ea_n_used, key, val);
  549|   224k|    ar_set_size(h, ++size);
  550|   224k|    ar_set_ea_n_used(h, ++ea_n_used);
  551|   224k|  }
  552|   226k|}
hash.c:ea_get_by_key:
  456|   226k|{
  457|   226k|  ea_each(ea, size, entry, {
  ------------------
  |  |  178|   226k|#define ea_each(ea, size, entry_var, code) do {                               \
  |  |  179|   226k|  hash_entry *entry_var = ea;                                                 \
  |  |  180|   226k|  uint32_t size__ = size;                                                     \
  |  |  181|  1.70M|  for (; 0 < size__; entry_var++) {                                           \
  |  |  ------------------
  |  |  |  Branch (181:10): [True: 1.48M, False: 225k]
  |  |  ------------------
  |  |  182|  1.48M|    if (entry_deleted_p(entry_var)) continue;                                 \
  |  |  ------------------
  |  |  |  Branch (182:9): [True: 0, False: 1.48M]
  |  |  ------------------
  |  |  183|  1.48M|    --size__;                                                                 \
  |  |  184|  1.48M|    code;                                                                     \
  |  |  ------------------
  |  |  |  Branch (184:5): [True: 838, False: 1.48M]
  |  |  ------------------
  |  |  185|  1.48M|  }                                                                           \
  |  |  186|   226k|} while (0)
  |  |  ------------------
  |  |  |  Branch (186:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  458|   226k|    if (obj_eql(mrb, key, entry->key, h)) return entry;
  459|   226k|  });
  460|   225k|  return NULL;
  461|   226k|}
hash.c:ar_adjust_ea:
  495|  46.8k|{
  496|  46.8k|  uint32_t ea_capa = size;
  497|  46.8k|  hash_entry *ea = ea_adjust(mrb, ar_ea(h), &ea_capa, max_ea_capa);
  498|  46.8k|  ar_set_ea(h, ea);
  499|  46.8k|  ar_set_ea_capa(h, ea_capa);
  500|  46.8k|}
hash.c:ea_adjust:
  440|  48.0k|{
  441|  48.0k|  *capap = ea_next_capa_for(*capap, max_capa);
  442|  48.0k|  return ea_resize(mrb, ea, *capap);
  443|  48.0k|}
hash.c:ea_next_capa_for:
  399|  48.0k|{
  400|  48.0k|  if (size < AR_DEFAULT_CAPA) {
  ------------------
  |  |   69|  48.0k|#define AR_DEFAULT_CAPA 4
  ------------------
  |  Branch (400:7): [True: 15.6k, False: 32.4k]
  ------------------
  401|  15.6k|    return AR_DEFAULT_CAPA;
  ------------------
  |  |   69|  15.6k|#define AR_DEFAULT_CAPA 4
  ------------------
  402|  15.6k|  }
  403|  32.4k|  else {
  404|       |    /*
  405|       |     * For 32-bit CPU, the theoretical value of maximum EA capacity is
  406|       |     * `UINT32_MAX / sizeof (hash_entry)`. At this time, if
  407|       |     * `EA_INCREASE_RATIO` is the current value, 32-bit range will not be
  408|       |     * exceeded during the calculation of `capa`, so `size_t` is used.
  409|       |     */
  410|  32.4k|    size_t capa = (size_t)size * EA_INCREASE_RATIO, inc = capa - size;
  ------------------
  |  |   58|  32.4k|#define EA_INCREASE_RATIO 6 / 5 + 6
  ------------------
  411|  32.4k|    if (EA_MAX_INCREASE < inc) capa = size + EA_MAX_INCREASE;
  ------------------
  |  |   59|  32.4k|#define EA_MAX_INCREASE UINT16_MAX
  ------------------
                  if (EA_MAX_INCREASE < inc) capa = size + EA_MAX_INCREASE;
  ------------------
  |  |   59|      0|#define EA_MAX_INCREASE UINT16_MAX
  ------------------
  |  Branch (411:9): [True: 0, False: 32.4k]
  ------------------
  412|  32.4k|    return capa <= max_capa ? U32(capa) : max_capa;
  ------------------
  |  |  285|  16.8k|#define U32(v) ((uint32_t)(v))
  ------------------
  |  Branch (412:12): [True: 16.8k, False: 15.6k]
  ------------------
  413|  32.4k|  }
  414|  48.0k|}
hash.c:ea_set:
  471|   240k|{
  472|   240k|  ea[index].key = key;
  473|   240k|  ea[index].val = val;
  474|   240k|}
hash.c:ht_set:
  878|   118k|{
  879|   118k|  uint32_t size = ht_size(h);
  880|   118k|  uint32_t ib_bit_width = ib_bit(h), ib_capa = ib_bit_to_capa(ib_bit_width);
  881|   118k|  if (ib_upper_bound_for(ib_capa) <= size) {
  ------------------
  |  Branch (881:7): [True: 135, False: 118k]
  ------------------
  882|    135|    if (size != ht_ea_n_used(h)) ea_compress(ht_ea(h), ht_ea_n_used(h));
  ------------------
  |  Branch (882:9): [True: 0, False: 135]
  ------------------
  883|    135|    ht_init(mrb, h, size, ht_ea(h), ht_ea_capa(h), h_ht(h), ++ib_bit_width);
  884|    135|  }
  885|   118k|  else if (size != ht_ea_n_used(h)) {
  ------------------
  |  Branch (885:12): [True: 0, False: 118k]
  ------------------
  886|      0|    if (ib_capa - EA_N_RESERVED_INDICES <= ht_ea_n_used(h)) goto compress;
  ------------------
  |  |   57|      0|#define EA_N_RESERVED_INDICES 2  /* empty and deleted */
  ------------------
  |  Branch (886:9): [True: 0, False: 0]
  ------------------
  887|      0|    if (ht_ea_capa(h) == ht_ea_n_used(h)) {
  ------------------
  |  Branch (887:9): [True: 0, False: 0]
  ------------------
  888|      0|      if (size <= AR_MAX_SIZE) {ht_set_as_ar(mrb, h, key, val); return;}
  ------------------
  |  |   70|      0|#define AR_MAX_SIZE 16
  ------------------
  |  Branch (888:11): [True: 0, False: 0]
  ------------------
  889|      0|      if (ea_next_capa_for(size, EA_MAX_CAPA) <= ht_ea_capa(h)) {
  ------------------
  |  |   60|      0|#define EA_MAX_CAPA U32(lesser(IB_MAX_CAPA - EA_N_RESERVED_INDICES, MRB_INT_MAX))
  |  |  ------------------
  |  |  |  |  285|      0|#define U32(v) ((uint32_t)(v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:28): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (889:11): [True: 0, False: 0]
  ------------------
  890|      0|       compress:
  891|      0|        ea_compress(ht_ea(h), ht_ea_n_used(h));
  892|      0|        ht_adjust_ea(mrb, h, size, ht_ea_capa(h));
  893|      0|        ht_init(mrb, h, size, ht_ea(h), ht_ea_capa(h), h_ht(h), ib_bit_width);
  894|      0|      }
  895|      0|    }
  896|      0|  }
  897|   118k|  ht_set_without_ib_adjustment(mrb, h, key, val);
  898|   118k|}
hash.c:ht_adjust_ea:
  815|  1.19k|{
  816|  1.19k|  uint32_t ea_capa = size;
  817|  1.19k|  hash_entry *ea = ea_adjust(mrb, ht_ea(h), &ea_capa, max_ea_capa);
  818|  1.19k|  ht_set_ea(h, ea);
  819|  1.19k|  ht_set_ea_capa(h, ea_capa);
  820|  1.19k|}
hash.c:ht_set_without_ib_adjustment:
  853|   118k|{
  854|   118k|  mrb_assert(ht_size(h) < ib_bit_to_capa(ib_bit(h)));
  ------------------
  |  |   68|   118k|#define mrb_assert(p) ((void)0)
  ------------------
  855|   118k|  ib_cycle_by_key(mrb, h, key, it, {
  ------------------
  |  |  188|   118k|#define ib_cycle_by_key(mrb, h, key, it_var, code) do {                       \
  |  |  189|   118k|  index_buckets_iter it_var[1];                                               \
  |  |  190|   118k|  ib_it_init(mrb, it_var, h, key);                                            \
  |  |  191|   142k|  for (;;) {                                                                  \
  |  |  192|   142k|    ib_it_next(it_var);                                                       \
  |  |  193|   740k|    code;                                                                     \
  |  |  ------------------
  |  |  |  Branch (193:5): [True: 24.1k, False: 101k]
  |  |  |  Branch (193:5): [Folded - Ignored]
  |  |  |  Branch (193:5): [True: 0, False: 16.2k]
  |  |  |  Branch (193:5): [Folded - Ignored]
  |  |  |  Branch (193:5): [True: 1.19k, False: 15.0k]
  |  |  |  Branch (193:5): [True: 126k, False: 16.2k]
  |  |  ------------------
  |  |  194|      0|  }                                                                           \
  |  |  195|   118k|} while (0)
  |  |  ------------------
  |  |  |  Branch (195:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  856|   118k|    if (ib_it_active_p(it)) {
  857|   118k|      if (!obj_eql(mrb, key, ib_it_entry(it)->key, h)) continue;
  858|   118k|      ib_it_entry(it)->val = val;
  859|   118k|    }
  860|   118k|    else {
  861|   118k|      uint32_t ea_n_used = ht_ea_n_used(h);
  862|   118k|      if (ea_n_used == H_MAX_SIZE) {
  863|   118k|        mrb_assert(ht_size(h) == ea_n_used);
  864|   118k|        mrb_raise(mrb, E_ARGUMENT_ERROR, "hash too big");
  865|   118k|      }
  866|   118k|      if (ea_n_used == ht_ea_capa(h)) ht_adjust_ea(mrb, h, ea_n_used, EA_MAX_CAPA);
  867|   118k|      ib_it_set(it, ea_n_used);
  868|   118k|      ea_set(ht_ea(h), ea_n_used, key, val);
  869|   118k|      ht_inc_size(h);
  870|   118k|      ht_set_ea_n_used(h, ++ea_n_used);
  871|   118k|    }
  872|   118k|    return;
  873|   118k|  });
  874|   118k|}
hash.c:ib_it_active_p:
  635|   142k|{
  636|   142k|  return it->ea_index < ib_it_deleted_value(it);
  637|   142k|}
hash.c:ht_inc_size:
  129|  16.2k|  MRB_INLINE void c_##_inc_##n_(struct RHash *h) {                            \
  130|  16.2k|    c_##_set_##n_(h, c_##_##n_(h) + 1);                                       \
  131|  16.2k|  }
hash.c:h_clear:
  999|  2.77k|{
 1000|  2.77k|  h_free_table(mrb, h);
 1001|  2.77k|  h_init(h);
 1002|  2.77k|}
hash.c:h_init:
  987|  2.77k|{
  988|  2.77k|  ar_init(h, 0, NULL, 0, 0);
  989|  2.77k|}

mrb_init_core:
   31|  1.74k|{
   32|  1.74k|  mrb_init_symtbl(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   33|       |
   34|  1.74k|  mrb_init_class(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   35|  1.74k|  mrb_init_object(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   36|  1.74k|  mrb_init_kernel(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   37|  1.74k|  mrb_init_comparable(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   38|  1.74k|  mrb_init_enumerable(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   39|       |
   40|  1.74k|  mrb_init_symbol(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   41|  1.74k|  mrb_init_string(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   42|  1.74k|  mrb_init_exception(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   43|  1.74k|  mrb_init_proc(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   44|  1.74k|  mrb_init_array(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   45|  1.74k|  mrb_init_hash(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   46|  1.74k|  mrb_init_numeric(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   47|  1.74k|  mrb_init_range(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   48|  1.74k|  mrb_init_gc(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   49|  1.74k|  mrb_init_version(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   50|  1.74k|  mrb_init_mrblib(mrb); DONE;
  ------------------
  |  |   28|  1.74k|#define DONE mrb_gc_arena_restore(mrb, 0);
  |  |  ------------------
  |  |  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  |  |  ------------------
  ------------------
   51|  1.74k|}

mrb_func_basic_p:
   21|   977k|{
   22|   977k|  struct RClass *c = mrb_class(mrb, obj);
   23|   977k|  mrb_method_t m = mrb_method_search_vm(mrb, &c, mid);
   24|   977k|  const struct RProc *p;
   25|       |
   26|   977k|  if (MRB_METHOD_UNDEF_P(m)) return FALSE;
  ------------------
  |  |  115|   977k|#define MRB_METHOD_UNDEF_P(m) ((m)==0)
  |  |  ------------------
  |  |  |  Branch (115:31): [True: 0, False: 977k]
  |  |  ------------------
  ------------------
                if (MRB_METHOD_UNDEF_P(m)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
   27|   977k|  if (MRB_METHOD_FUNC_P(m))
  ------------------
  |  |  107|   977k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  ------------------
  |  |  |  |  102|   977k|#define MRB_METHOD_FUNC_FL 1
  |  |  ------------------
  |  |  |  Branch (107:30): [True: 977k, False: 0]
  |  |  ------------------
  ------------------
   28|   977k|    return MRB_METHOD_FUNC(m) == func;
  ------------------
  |  |  110|   977k|#define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)>>2))
  ------------------
   29|      0|  p = MRB_METHOD_PROC(m);
  ------------------
  |  |  114|      0|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  ------------------
   30|      0|  if (MRB_PROC_CFUNC_P(p) && (MRB_PROC_CFUNC(p) == func))
  ------------------
  |  |   65|      0|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  |  |  |  Branch (65:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                if (MRB_PROC_CFUNC_P(p) && (MRB_PROC_CFUNC(p) == func))
  ------------------
  |  |   66|      0|#define MRB_PROC_CFUNC(p) (p)->body.func
  ------------------
  |  Branch (30:30): [True: 0, False: 0]
  ------------------
   31|      0|    return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
   32|      0|  return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
   33|      0|}
mrb_obj_freeze:
  231|     72|{
  232|     72|  if (!mrb_immediate_p(self)) {
  ------------------
  |  |  148|     72|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|    144|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 0, False: 72]
  |  |  |  Branch (148:63): [True: 0, False: 72]
  |  |  ------------------
  ------------------
  233|     72|    struct RBasic *b = mrb_basic_ptr(self);
  ------------------
  |  |   22|     72|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|     72|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  234|     72|    if (!mrb_frozen_p(b)) {
  ------------------
  |  |   28|     72|#define mrb_frozen_p(o) MRB_FROZEN_P(o)
  |  |  ------------------
  |  |  |  |   25|     72|#define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
  |  |  |  |  ------------------
  |  |  |  |  |  |   24|     72|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (234:9): [True: 72, False: 0]
  ------------------
  235|     72|      MRB_SET_FROZEN_FLAG(b);
  ------------------
  |  |   26|     72|#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
  |  |  ------------------
  |  |  |  |   24|     72|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  ------------------
  ------------------
  236|     72|      if (b->c->tt == MRB_TT_SCLASS) MRB_SET_FROZEN_FLAG(b->c);
  ------------------
  |  |   26|      0|#define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
  |  |  ------------------
  |  |  |  |   24|      0|#define MRB_FL_OBJ_IS_FROZEN (1 << 20)
  |  |  ------------------
  ------------------
  |  Branch (236:11): [True: 0, False: 72]
  ------------------
  237|     72|    }
  238|     72|  }
  239|     72|  return self;
  240|     72|}
mrb_f_raise:
  382|     21|{
  383|     21|  mrb_value exc, mesg;
  384|     21|  mrb_int argc;
  385|       |
  386|     21|  argc = mrb_get_args(mrb, "|oo", &exc, &mesg);
  387|     21|  mrb->c->ci->mid = 0;
  388|     21|  switch (argc) {
  389|      0|  case 0:
  ------------------
  |  Branch (389:3): [True: 0, False: 21]
  ------------------
  390|      0|    mrb_raise(mrb, E_RUNTIME_ERROR, "");
  ------------------
  |  | 1374|      0|#define E_RUNTIME_ERROR      mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  391|      0|    break;
  392|      0|  case 1:
  ------------------
  |  Branch (392:3): [True: 0, False: 21]
  ------------------
  393|      0|    if (mrb_string_p(exc)) {
  ------------------
  |  |  187|      0|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  394|      0|      mesg = exc;
  395|      0|      exc = mrb_obj_value(E_RUNTIME_ERROR);
  ------------------
  |  | 1374|      0|#define E_RUNTIME_ERROR      mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  396|      0|    }
  397|      0|    else {
  398|      0|      mesg = mrb_nil_value();
  399|      0|    }
  400|       |    /* fall through */
  401|     21|  default:
  ------------------
  |  Branch (401:3): [True: 21, False: 0]
  ------------------
  402|     21|    exc = mrb_make_exception(mrb, exc, mesg);
  403|     21|    mrb_exc_raise(mrb, exc);
  404|      0|    break;
  405|     21|  }
  406|      0|  return mrb_nil_value();            /* not reached */
  407|     21|}
mrb_init_kernel:
  539|  1.74k|{
  540|  1.74k|  struct RClass *krn;
  541|       |
  542|  1.74k|  mrb->kernel_module = krn = mrb_define_module(mrb, "Kernel");                                                    /* 15.3.1 */
  543|  1.74k|  mrb_define_class_method(mrb, krn, "block_given?",         mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.2.2  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  544|  1.74k|  mrb_define_class_method(mrb, krn, "iterator?",            mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.2.5  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  545|  1.74k|  mrb_define_class_method(mrb, krn, "raise",                mrb_f_raise,                     MRB_ARGS_OPT(2));    /* 15.3.1.2.12 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
  546|       |
  547|       |
  548|  1.74k|  mrb_define_method(mrb, krn, "===",                        mrb_equal_m,                     MRB_ARGS_REQ(1));    /* 15.3.1.3.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  549|  1.74k|  mrb_define_method(mrb, krn, "<=>",                        mrb_cmp_m,                       MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  550|  1.74k|  mrb_define_method(mrb, krn, "block_given?",               mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.3.6  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  551|  1.74k|  mrb_define_method(mrb, krn, "class",                      mrb_obj_class_m,                 MRB_ARGS_NONE());    /* 15.3.1.3.7  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  552|  1.74k|  mrb_define_method(mrb, krn, "clone",                      mrb_obj_clone,                   MRB_ARGS_NONE());    /* 15.3.1.3.8  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  553|  1.74k|  mrb_define_method(mrb, krn, "dup",                        mrb_obj_dup,                     MRB_ARGS_NONE());    /* 15.3.1.3.9  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  554|  1.74k|  mrb_define_method(mrb, krn, "eql?",                       mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.10 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  555|  1.74k|  mrb_define_method(mrb, krn, "freeze",                     mrb_obj_freeze,                  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  556|  1.74k|  mrb_define_method(mrb, krn, "frozen?",                    mrb_obj_frozen,                  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  557|  1.74k|  mrb_define_method(mrb, krn, "hash",                       mrb_obj_hash,                    MRB_ARGS_NONE());    /* 15.3.1.3.15 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  558|  1.74k|  mrb_define_method(mrb, krn, "initialize_copy",            mrb_obj_init_copy,               MRB_ARGS_REQ(1));    /* 15.3.1.3.16 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  559|  1.74k|  mrb_define_method(mrb, krn, "inspect",                    mrb_obj_inspect,                 MRB_ARGS_NONE());    /* 15.3.1.3.17 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  560|  1.74k|  mrb_define_method(mrb, krn, "instance_of?",               obj_is_instance_of,              MRB_ARGS_REQ(1));    /* 15.3.1.3.19 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  561|       |
  562|  1.74k|  mrb_define_method(mrb, krn, "is_a?",                      mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.24 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  563|  1.74k|  mrb_define_method(mrb, krn, "iterator?",                  mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.3.25 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  564|  1.74k|  mrb_define_method(mrb, krn, "kind_of?",                   mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.26 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  565|  1.74k|  mrb_define_method(mrb, krn, "nil?",                       mrb_false,                       MRB_ARGS_NONE());    /* 15.3.1.3.32 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  566|  1.74k|  mrb_define_method(mrb, krn, "object_id",                  mrb_obj_id_m,                    MRB_ARGS_NONE());    /* 15.3.1.3.33 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  567|  1.74k|  mrb_define_method(mrb, krn, "raise",                      mrb_f_raise,                     MRB_ARGS_ANY());     /* 15.3.1.3.40 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  568|  1.74k|  mrb_define_method(mrb, krn, "remove_instance_variable",   mrb_obj_remove_instance_variable,MRB_ARGS_REQ(1));    /* 15.3.1.3.41 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  569|  1.74k|  mrb_define_method(mrb, krn, "respond_to?",                obj_respond_to,                  MRB_ARGS_ARG(1,1));     /* 15.3.1.3.43 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
  570|  1.74k|  mrb_define_method(mrb, krn, "to_s",                       mrb_any_to_s,                    MRB_ARGS_NONE());    /* 15.3.1.3.46 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  571|  1.74k|  mrb_define_method(mrb, krn, "__case_eqq",                 mrb_obj_ceqq,                    MRB_ARGS_REQ(1));    /* internal */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  572|  1.74k|  mrb_define_method(mrb, krn, "__to_int",                   mrb_ensure_int_type,             MRB_ARGS_NONE());    /* internal */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  573|  1.74k|  mrb_define_method(mrb, krn, "__ENCODING__",               mrb_encoding,                    MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  574|       |
  575|  1.74k|  mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
  576|  1.74k|}
kernel.c:mrb_obj_is_kind_of_m:
  337|  40.8k|{
  338|  40.8k|  struct RClass *c;
  339|       |
  340|  40.8k|  mrb_get_args(mrb, "c", &c);
  341|       |
  342|  40.8k|  return mrb_bool_value(mrb_obj_is_kind_of(mrb, self, c));
  343|  40.8k|}
kernel.c:mrb_false:
  355|  1.59k|{
  356|  1.59k|  return mrb_false_value();
  357|  1.59k|}

mrb_load_proc:
  713|  45.3k|{
  714|  45.3k|  return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
  715|  45.3k|}

mrb_int_overflow:
   26|      6|{
   27|      6|  mrb_raisef(mrb, E_RANGE_ERROR, "integer overflow in %s", reason);
  ------------------
  |  | 1379|      6|#define E_RANGE_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(RangeError))
  |  |  ------------------
  |  |  |  |   35|      6|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      6|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   28|      6|}
mrb_int_zerodiv:
   32|     44|{
   33|     44|  mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
  ------------------
  |  | 1376|     44|#define E_ZERODIV_ERROR      mrb_exc_get_id(mrb, MRB_ERROR_SYM(ZeroDivisionError))
  |  |  ------------------
  |  |  |  |   35|     44|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     44|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   34|     44|}
mrb_div_int:
  118|  5.40k|{
  119|  5.40k|  mrb_int div = x / y;
  120|       |
  121|  5.40k|  if ((x ^ y) < 0 && x != div * y) {
  ------------------
  |  Branch (121:7): [True: 2.07k, False: 3.33k]
  |  Branch (121:22): [True: 722, False: 1.35k]
  ------------------
  122|    722|    div -= 1;
  123|    722|  }
  124|  5.40k|  return div;
  125|  5.40k|}
mrb_div_int_value:
  129|  1.71k|{
  130|  1.71k|  if (y == 0) {
  ------------------
  |  Branch (130:7): [True: 15, False: 1.70k]
  ------------------
  131|     15|    mrb_int_zerodiv(mrb);
  132|     15|  }
  133|  1.70k|  else if (x == MRB_INT_MIN && y == -1) {
  ------------------
  |  |   81|  3.40k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (133:12): [True: 362, False: 1.33k]
  |  Branch (133:32): [True: 272, False: 90]
  ------------------
  134|    272|#ifdef MRB_USE_BIGINT
  135|    272|    return mrb_bint_mul_ii(mrb, x, y);
  136|       |#else
  137|       |    mrb_int_overflow(mrb, "division");
  138|       |#endif
  139|    272|  }
  140|  1.42k|  return mrb_int_value(mrb, mrb_div_int(x, y));
  141|  1.71k|}
mrb_div_float:
  301|  1.95k|{
  302|  1.95k|  if (y != 0.0) {
  ------------------
  |  Branch (302:7): [True: 1.56k, False: 396]
  ------------------
  303|  1.56k|    return x / y;
  304|  1.56k|  }
  305|    396|  else if (x == 0.0) {
  ------------------
  |  Branch (305:12): [True: 83, False: 313]
  ------------------
  306|     83|    return NAN;
  307|     83|  }
  308|    313|  else {
  309|    313|    return x * (signbit(y) ? -1.0 : 1.0) * INFINITY;
  310|    313|  }
  311|  1.95k|}
mrb_float_to_str:
  344|      1|{
  345|      1|  char buf[25];
  346|       |#ifdef MRB_USE_FLOAT32
  347|       |  const int prec =  7;
  348|       |#else
  349|      1|  const int prec =  15;
  350|      1|#endif
  351|       |
  352|      1|  mrb_format_float(mrb_float(flo), buf, sizeof(buf), 'g', prec, '\0');
  ------------------
  |  |  155|      1|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  353|      3|  for (char *p = buf; *p; p++) {
  ------------------
  |  Branch (353:23): [True: 3, False: 0]
  ------------------
  354|      3|    if (*p == '.') goto exit;
  ------------------
  |  Branch (354:9): [True: 1, False: 2]
  ------------------
  355|      2|    if (*p == 'e') {
  ------------------
  |  Branch (355:9): [True: 0, False: 2]
  ------------------
  356|      0|      memmove(p+2, p, strlen(p)+1);
  357|      0|      memcpy(p, ".0", 2);
  358|      0|      goto exit;
  359|      0|    }
  360|      2|  }
  361|      0|  strcat(buf, ".0");
  362|      1| exit:
  363|      1|  return mrb_str_new_cstr(mrb, buf);
  364|      0|}
mrb_check_num_exact:
  815|    803|{
  816|    803|  if (isinf(num)) {
  817|      0|    mrb_raise(mrb, E_FLOATDOMAIN_ERROR, num < 0 ? "-Infinity" : "Infinity");
  ------------------
  |  | 1390|      0|# define E_FLOATDOMAIN_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FloatDomainError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (817:41): [True: 0, False: 0]
  ------------------
  818|      0|  }
  819|    803|  if (isnan(num)) {
  820|      0|    mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
  ------------------
  |  | 1390|      0|# define E_FLOATDOMAIN_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FloatDomainError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  821|      0|  }
  822|    803|}
mrb_int_mul:
 1122|  1.19k|{
 1123|  1.19k|  mrb_int a;
 1124|       |
 1125|  1.19k|  a = mrb_integer(x);
  ------------------
  |  |  166|  1.19k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1126|  1.19k|  if (mrb_integer_p(y)) {
  ------------------
  |  |  171|  1.19k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  2.38k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 1.19k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  1.19k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  2.38k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  2.38k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 11, False: 1.18k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.18k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 1.18k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1127|      0|    mrb_int b, c;
 1128|       |
 1129|      0|    if (a == 0) return x;
  ------------------
  |  Branch (1129:9): [True: 0, False: 0]
  ------------------
 1130|      0|    if (a == 1) return y;
  ------------------
  |  Branch (1130:9): [True: 0, False: 0]
  ------------------
 1131|      0|    b = mrb_integer(y);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1132|      0|    if (b == 0) return y;
  ------------------
  |  Branch (1132:9): [True: 0, False: 0]
  ------------------
 1133|      0|    if (b == 1) return x;
  ------------------
  |  Branch (1133:9): [True: 0, False: 0]
  ------------------
 1134|      0|    if (mrb_int_mul_overflow(a, b, &c)) {
  ------------------
  |  Branch (1134:9): [True: 0, False: 0]
  ------------------
 1135|      0|#ifdef MRB_USE_BIGINT
 1136|      0|      x = mrb_bint_new_int(mrb, a);
 1137|      0|      return mrb_bint_mul(mrb, x, y);
 1138|       |#else
 1139|       |      mrb_int_overflow(mrb, "multiplication");
 1140|       |#endif
 1141|      0|    }
 1142|      0|    return mrb_int_value(mrb, c);
 1143|      0|  }
 1144|  1.19k|  switch (mrb_type(y)) {
 1145|      0|#ifdef MRB_USE_BIGINT
 1146|  1.18k|  case MRB_TT_BIGINT:
  ------------------
  |  Branch (1146:3): [True: 1.18k, False: 11]
  ------------------
 1147|  1.18k|    if (a == 0) return x;
  ------------------
  |  Branch (1147:9): [True: 280, False: 900]
  ------------------
 1148|    900|    if (a == 1) return y;
  ------------------
  |  Branch (1148:9): [True: 565, False: 335]
  ------------------
 1149|    335|    return mrb_bint_mul(mrb, y, x);
 1150|      0|#endif
 1151|      0|#ifdef MRB_USE_RATIONAL
 1152|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (1152:3): [True: 0, False: 1.19k]
  ------------------
 1153|      0|    if (a == 0) return x;
  ------------------
  |  Branch (1153:9): [True: 0, False: 0]
  ------------------
 1154|      0|    if (a == 1) return y;
  ------------------
  |  Branch (1154:9): [True: 0, False: 0]
  ------------------
 1155|      0|    return mrb_rational_mul(mrb, y, x);
 1156|      0|#endif
 1157|      0|#ifdef MRB_USE_COMPLEX
 1158|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (1158:3): [True: 0, False: 1.19k]
  ------------------
 1159|      0|    if (a == 0) return x;
  ------------------
  |  Branch (1159:9): [True: 0, False: 0]
  ------------------
 1160|      0|    if (a == 1) return y;
  ------------------
  |  Branch (1160:9): [True: 0, False: 0]
  ------------------
 1161|      0|    return mrb_complex_mul(mrb, y, x);
 1162|      0|#endif
 1163|      0|#ifndef MRB_NO_FLOAT
 1164|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (1164:3): [True: 0, False: 1.19k]
  ------------------
 1165|      0|    return mrb_float_value(mrb, (mrb_float)a * mrb_as_float(mrb, y));
  ------------------
  |  | 1297|      0|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 1166|      0|#endif
 1167|     11|  default:
  ------------------
  |  Branch (1167:3): [True: 11, False: 1.18k]
  ------------------
 1168|     11|    mrb_int_noconv(mrb, y);
 1169|  1.19k|  }
 1170|  1.19k|}
mrb_num_shift:
 1470|  10.0k|{
 1471|  10.0k|  if (width < 0) {              /* rshift */
  ------------------
  |  Branch (1471:7): [True: 3.43k, False: 6.60k]
  ------------------
 1472|  3.43k|    if (width == MRB_INT_MIN || -width >= NUMERIC_SHIFT_WIDTH_MAX) {
  ------------------
  |  |   81|  6.86k|# define MRB_INT_MIN INT64_MIN
  ------------------
                  if (width == MRB_INT_MIN || -width >= NUMERIC_SHIFT_WIDTH_MAX) {
  ------------------
  |  | 1466|  3.43k|#define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1)
  |  |  ------------------
  |  |  |  |   80|  3.43k|# define MRB_INT_BIT 64
  |  |  ------------------
  ------------------
  |  Branch (1472:9): [True: 0, False: 3.43k]
  |  Branch (1472:33): [True: 669, False: 2.76k]
  ------------------
 1473|    669|      if (val < 0) {
  ------------------
  |  Branch (1473:11): [True: 173, False: 496]
  ------------------
 1474|    173|        *num = -1;
 1475|    173|      }
 1476|    496|      else {
 1477|    496|        *num = 0;
 1478|    496|      }
 1479|    669|    }
 1480|  2.76k|    else {
 1481|  2.76k|      *num = val >> -width;
 1482|  2.76k|    }
 1483|  3.43k|  }
 1484|  6.60k|  else if (val > 0) {
  ------------------
  |  Branch (1484:12): [True: 5.32k, False: 1.28k]
  ------------------
 1485|  5.32k|    if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
  ------------------
  |  | 1466|  5.32k|#define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1)
  |  |  ------------------
  |  |  |  |   80|  5.32k|# define MRB_INT_BIT 64
  |  |  ------------------
  ------------------
  |  Branch (1485:9): [True: 727, False: 4.59k]
  ------------------
 1486|  5.32k|        (val   > (MRB_INT_MAX >> width))) {
  ------------------
  |  |   82|  4.59k|# define MRB_INT_MAX INT64_MAX
  ------------------
  |  Branch (1486:9): [True: 2.32k, False: 2.27k]
  ------------------
 1487|  3.05k|      return FALSE;
  ------------------
  |  |   51|  3.05k|#  define FALSE 0
  ------------------
 1488|  3.05k|    }
 1489|  2.27k|    *num = val << width;
 1490|  2.27k|  }
 1491|  1.28k|  else {
 1492|  1.28k|    if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
  ------------------
  |  | 1466|  1.28k|#define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1)
  |  |  ------------------
  |  |  |  |   80|  1.28k|# define MRB_INT_BIT 64
  |  |  ------------------
  ------------------
  |  Branch (1492:9): [True: 135, False: 1.15k]
  ------------------
 1493|  1.28k|        (val   < (MRB_INT_MIN >> width))) {
  ------------------
  |  |   81|  1.15k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (1493:9): [True: 240, False: 910]
  ------------------
 1494|    375|      return FALSE;
  ------------------
  |  |   51|    375|#  define FALSE 0
  ------------------
 1495|    375|    }
 1496|    910|    if (width == NUMERIC_SHIFT_WIDTH_MAX)
  ------------------
  |  | 1466|    910|#define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1)
  |  |  ------------------
  |  |  |  |   80|    910|# define MRB_INT_BIT 64
  |  |  ------------------
  ------------------
  |  Branch (1496:9): [True: 674, False: 236]
  ------------------
 1497|    674|      *num = MRB_INT_MIN;
  ------------------
  |  |   81|    674|# define MRB_INT_MIN INT64_MIN
  ------------------
 1498|    236|    else
 1499|    236|      *num = val * ((mrb_int)1 << width);
 1500|    910|  }
 1501|  6.61k|  return TRUE;
  ------------------
  |  |   54|  6.61k|#  define TRUE 1
  ------------------
 1502|  10.0k|}
mrb_float_to_integer:
 1799|    806|{
 1800|    806|  if (!mrb_float_p(x)) {
  ------------------
  |  |  179|    806|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|    806|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
  |  Branch (1800:7): [True: 0, False: 806]
  ------------------
 1801|      0|    mrb_raise(mrb, E_TYPE_ERROR, "non float value");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1802|      0|  }
 1803|    806|  mrb_float f = mrb_float(x);
  ------------------
  |  |  155|    806|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1804|    806|  if (isinf(f) || isnan(f)) {
 1805|      3|    mrb_raisef(mrb, E_RANGE_ERROR, "float %f out of range", f);
  ------------------
  |  | 1379|      3|#define E_RANGE_ERROR        mrb_exc_get_id(mrb, MRB_ERROR_SYM(RangeError))
  |  |  ------------------
  |  |  |  |   35|      3|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      3|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1806|      3|  }
 1807|    803|  return flo_to_i(mrb, x);
 1808|    806|}
mrb_int_add:
 1813|  1.63k|{
 1814|  1.63k|  mrb_int a;
 1815|       |
 1816|  1.63k|  a = mrb_integer(x);
  ------------------
  |  |  166|  1.63k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1817|  1.63k|  if (mrb_integer_p(y)) {
  ------------------
  |  |  171|  1.63k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  3.26k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 1.63k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  1.63k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.26k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.26k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 13, False: 1.61k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.61k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 1.61k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1818|      0|    mrb_int b, c;
 1819|       |
 1820|      0|    if (a == 0) return y;
  ------------------
  |  Branch (1820:9): [True: 0, False: 0]
  ------------------
 1821|      0|    b = mrb_integer(y);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1822|      0|    if (b == 0) return x;
  ------------------
  |  Branch (1822:9): [True: 0, False: 0]
  ------------------
 1823|      0|    if (mrb_int_add_overflow(a, b, &c)) {
  ------------------
  |  Branch (1823:9): [True: 0, False: 0]
  ------------------
 1824|      0|#ifdef MRB_USE_BIGINT
 1825|      0|      x = mrb_bint_new_int(mrb, a);
 1826|      0|      return mrb_bint_add(mrb, x, y);
 1827|       |#else
 1828|       |      mrb_int_overflow(mrb, "addition");
 1829|       |#endif
 1830|      0|    }
 1831|      0|    return mrb_int_value(mrb, c);
 1832|      0|  }
 1833|  1.63k|  switch (mrb_type(y)) {
 1834|      0|#ifdef MRB_USE_BIGINT
 1835|  1.61k|  case MRB_TT_BIGINT:
  ------------------
  |  Branch (1835:3): [True: 1.61k, False: 13]
  ------------------
 1836|  1.61k|    return mrb_bint_add(mrb, y, x);
 1837|      0|#endif
 1838|      0|#ifdef MRB_USE_RATIONAL
 1839|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (1839:3): [True: 0, False: 1.63k]
  ------------------
 1840|      0|    return mrb_rational_add(mrb, y, x);
 1841|      0|#endif
 1842|      0|#ifdef MRB_USE_COMPLEX
 1843|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (1843:3): [True: 0, False: 1.63k]
  ------------------
 1844|      0|    return mrb_complex_add(mrb, y, x);
 1845|      0|#endif
 1846|     13|  default:
  ------------------
  |  Branch (1846:3): [True: 13, False: 1.61k]
  ------------------
 1847|       |#ifdef MRB_NO_FLOAT
 1848|       |    mrb_raise(mrb, E_TYPE_ERROR, "non integer addition");
 1849|       |#else
 1850|     13|    return mrb_float_value(mrb, (mrb_float)a + mrb_as_float(mrb, y));
  ------------------
  |  | 1297|     13|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|     13|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 1851|  1.63k|#endif
 1852|  1.63k|  }
 1853|  1.63k|}
mrb_int_sub:
 1879|  2.84k|{
 1880|  2.84k|  mrb_int a;
 1881|       |
 1882|  2.84k|  a = mrb_integer(x);
  ------------------
  |  |  166|  2.84k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1883|  2.84k|  if (mrb_integer_p(y)) {
  ------------------
  |  |  171|  2.84k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  5.68k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 2.84k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  2.84k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  5.68k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  5.68k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 9, False: 2.83k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 2.83k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 2.83k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1884|      0|    mrb_int b, c;
 1885|       |
 1886|      0|    b = mrb_integer(y);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1887|      0|    if (mrb_int_sub_overflow(a, b, &c)) {
  ------------------
  |  Branch (1887:9): [True: 0, False: 0]
  ------------------
 1888|      0|#ifdef MRB_USE_BIGINT
 1889|      0|      x = mrb_bint_new_int(mrb, a);
 1890|      0|      return mrb_bint_sub(mrb, x, y);
 1891|       |#else
 1892|       |      mrb_int_overflow(mrb, "subtraction");
 1893|       |#endif
 1894|      0|    }
 1895|      0|    return mrb_int_value(mrb, c);
 1896|      0|  }
 1897|  2.84k|  switch (mrb_type(y)) {
 1898|      0|#ifdef MRB_USE_BIGINT
 1899|  2.83k|  case MRB_TT_BIGINT:
  ------------------
  |  Branch (1899:3): [True: 2.83k, False: 9]
  ------------------
 1900|  2.83k|    return mrb_bint_sub(mrb, mrb_bint_new_int(mrb, a), y);
 1901|      0|#endif
 1902|      0|#ifdef MRB_USE_RATIONAL
 1903|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (1903:3): [True: 0, False: 2.84k]
  ------------------
 1904|      0|    return mrb_rational_sub(mrb, mrb_rational_new(mrb, a, 1), y);
 1905|      0|#endif
 1906|      0|#ifdef MRB_USE_COMPLEX
 1907|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (1907:3): [True: 0, False: 2.84k]
  ------------------
 1908|      0|    return mrb_complex_sub(mrb, mrb_complex_new(mrb, (mrb_float)a, 0), y);
 1909|      0|#endif
 1910|      9|  default:
  ------------------
  |  Branch (1910:3): [True: 9, False: 2.83k]
  ------------------
 1911|       |#ifdef MRB_NO_FLOAT
 1912|       |    mrb_raise(mrb, E_TYPE_ERROR, "non integer subtraction");
 1913|       |#else
 1914|      9|    return mrb_float_value(mrb, (mrb_float)a - mrb_as_float(mrb, y));
  ------------------
  |  | 1297|      9|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|      9|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 1915|  2.84k|#endif
 1916|  2.84k|  }
 1917|  2.84k|}
mrb_int_to_cstr:
 1943|    167|{
 1944|    167|  char *bufend = buf + len;
 1945|    167|  char *b = bufend-1;
 1946|       |
 1947|    167|  if (base < 2 || 36 < base) return NULL;
  ------------------
  |  Branch (1947:7): [True: 0, False: 167]
  |  Branch (1947:19): [True: 0, False: 167]
  ------------------
 1948|    167|  if (len < 2) return NULL;
  ------------------
  |  Branch (1948:7): [True: 0, False: 167]
  ------------------
 1949|       |
 1950|    167|  if (n == 0) {
  ------------------
  |  Branch (1950:7): [True: 52, False: 115]
  ------------------
 1951|     52|    buf[0] = '0';
 1952|     52|    buf[1] = '\0';
 1953|     52|    return buf;
 1954|     52|  }
 1955|       |
 1956|    115|  *b = '\0';
 1957|    115|  if (n < 0) {
  ------------------
  |  Branch (1957:7): [True: 21, False: 94]
  ------------------
 1958|     21|    do {
 1959|     21|      if (b-- == buf) return NULL;
  ------------------
  |  Branch (1959:11): [True: 0, False: 21]
  ------------------
 1960|     21|      *b = mrb_digitmap[-(n % base)];
 1961|     21|    } while (n /= base);
  ------------------
  |  Branch (1961:14): [True: 0, False: 21]
  ------------------
 1962|     21|    if (b-- == buf) return NULL;
  ------------------
  |  Branch (1962:9): [True: 0, False: 21]
  ------------------
 1963|     21|    *b = '-';
 1964|     21|  }
 1965|     94|  else {
 1966|     96|    do {
 1967|     96|      if (b-- == buf) return NULL;
  ------------------
  |  Branch (1967:11): [True: 0, False: 96]
  ------------------
 1968|     96|      *b = mrb_digitmap[(int)(n % base)];
 1969|     96|    } while (n /= base);
  ------------------
  |  Branch (1969:14): [True: 2, False: 94]
  ------------------
 1970|     94|  }
 1971|    115|  return b;
 1972|    115|}
mrb_integer_to_str:
 1976|    168|{
 1977|    168|  char buf[MRB_INT_BIT+1];
 1978|    168|  mrb_int val = mrb_integer(x);
  ------------------
  |  |  166|    168|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1979|       |
 1980|    168|  if (base < 2 || 36 < base) {
  ------------------
  |  Branch (1980:7): [True: 0, False: 168]
  |  Branch (1980:19): [True: 0, False: 168]
  ------------------
 1981|      0|    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %i", base);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1982|      0|  }
 1983|    168|#ifdef MRB_USE_BIGINT
 1984|    168|  if (mrb_bigint_p(x)) {
  ------------------
  |  |  314|    168|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 1, False: 167]
  |  |  ------------------
  ------------------
 1985|      1|    return mrb_bint_to_s(mrb, x, base);
 1986|      1|  }
 1987|    167|#endif
 1988|    167|  const char *p = mrb_int_to_cstr(buf, sizeof(buf), val, base);
 1989|    167|  mrb_assert(p != NULL);
  ------------------
  |  |   68|    167|#define mrb_assert(p) ((void)0)
  ------------------
 1990|    167|  mrb_value str = mrb_str_new_cstr(mrb, p);
 1991|    167|  RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
  ------------------
  |  |   89|    167|# define RSTR_SET_ASCII_FLAG(s) (void)0
  ------------------
 1992|    167|  return str;
 1993|    168|}
mrb_init_numeric:
 2210|  1.74k|{
 2211|  1.74k|  struct RClass *numeric, *integer;
 2212|  1.74k|#ifndef MRB_NO_FLOAT
 2213|  1.74k|  struct RClass *fl;
 2214|  1.74k|#endif
 2215|       |
 2216|       |  /* Numeric Class */
 2217|  1.74k|  numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);                /* 15.2.7 */
 2218|  1.74k|  mrb_define_method(mrb, numeric, "finite?",  num_finite_p,    MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2219|  1.74k|  mrb_define_method(mrb, numeric, "infinite?",num_infinite_p,  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2220|  1.74k|  mrb_define_method(mrb, numeric, "eql?",     num_eql,         MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2221|       |
 2222|       |  /* Integer Class */
 2223|  1.74k|  mrb->integer_class = integer = mrb_define_class(mrb, "Integer",  numeric);     /* 15.2.8 */
 2224|  1.74k|  MRB_SET_INSTANCE_TT(integer, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 2225|  1.74k|  mrb_undef_class_method(mrb, integer, "new");
 2226|  1.74k|  mrb_define_method(mrb, integer, "**",       int_pow,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2227|  1.74k|  mrb_define_method(mrb, integer, "<=>",      num_cmp,         MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2228|  1.74k|  mrb_define_method(mrb, integer, "<",        num_lt,          MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2229|  1.74k|  mrb_define_method(mrb, integer, "<=",       num_le,          MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2230|  1.74k|  mrb_define_method(mrb, integer, ">",        num_gt,          MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2231|  1.74k|  mrb_define_method(mrb, integer, ">=",       num_ge,          MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2232|       |
 2233|  1.74k|  mrb_define_method(mrb, integer, "to_i",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.24 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2234|  1.74k|  mrb_define_method(mrb, integer, "to_int",   int_to_i,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2235|       |
 2236|  1.74k|  mrb_define_method(mrb, integer, "+",        int_add,         MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2237|  1.74k|  mrb_define_method(mrb, integer, "-",        int_sub,         MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2238|  1.74k|  mrb_define_method(mrb, integer, "*",        int_mul,         MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2239|  1.74k|  mrb_define_method(mrb, integer, "%",        int_mod,         MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2240|  1.74k|  mrb_define_method(mrb, integer, "/",        int_div,         MRB_ARGS_REQ(1)); /* 15.2.8.3.6 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2241|  1.74k|  mrb_define_method(mrb, integer, "quo",      int_quo,         MRB_ARGS_REQ(1)); /* 15.2.7.4.5(x) */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2242|  1.74k|  mrb_define_method(mrb, integer, "div",      int_idiv,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2243|  1.74k|  mrb_define_method(mrb, integer, "==",       int_equal,       MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2244|  1.74k|  mrb_define_method(mrb, integer, "~",        int_rev,         MRB_ARGS_NONE()); /* 15.2.8.3.8 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2245|  1.74k|  mrb_define_method(mrb, integer, "&",        int_and,         MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2246|  1.74k|  mrb_define_method(mrb, integer, "|",        int_or,          MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2247|  1.74k|  mrb_define_method(mrb, integer, "^",        int_xor,         MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2248|  1.74k|  mrb_define_method(mrb, integer, "<<",       int_lshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2249|  1.74k|  mrb_define_method(mrb, integer, ">>",       int_rshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2250|  1.74k|  mrb_define_method(mrb, integer, "ceil",     int_ceil,        MRB_ARGS_OPT(1)); /* 15.2.8.3.14 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2251|  1.74k|  mrb_define_method(mrb, integer, "floor",    int_floor,       MRB_ARGS_OPT(1)); /* 15.2.8.3.17 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2252|  1.74k|  mrb_define_method(mrb, integer, "round",    int_round,       MRB_ARGS_OPT(1)); /* 15.2.8.3.20 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2253|  1.74k|  mrb_define_method(mrb, integer, "truncate", int_truncate,    MRB_ARGS_OPT(1)); /* 15.2.8.3.26 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2254|  1.74k|  mrb_define_method(mrb, integer, "hash",     int_hash,        MRB_ARGS_NONE()); /* 15.2.8.3.18 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2255|  1.74k|#ifndef MRB_NO_FLOAT
 2256|  1.74k|  mrb_define_method(mrb, integer, "to_f",     int_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2257|  1.74k|#endif
 2258|  1.74k|  mrb_define_method(mrb, integer, "to_s",     int_to_s,        MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2259|  1.74k|  mrb_define_method(mrb, integer, "inspect",  int_to_s,        MRB_ARGS_OPT(1));
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2260|  1.74k|  mrb_define_method(mrb, integer, "divmod",   int_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30(x) */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2261|  1.74k|  mrb_define_method(mrb, integer, "__coerce_step_counter", coerce_step_counter, MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2262|       |
 2263|       |  /* Fixnum Class for compatibility */
 2264|  1.74k|  mrb_define_const(mrb, mrb->object_class, "Fixnum", mrb_obj_value(integer));
 2265|       |
 2266|  1.74k|#ifndef MRB_NO_FLOAT
 2267|       |  /* Float Class */
 2268|  1.74k|  mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric);                 /* 15.2.9 */
 2269|  1.74k|  MRB_SET_INSTANCE_TT(fl, MRB_TT_UNDEF);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 2270|  1.74k|  mrb_undef_class_method(mrb,  fl, "new");
 2271|  1.74k|  mrb_define_method(mrb, fl,      "**",        flo_pow,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2272|  1.74k|  mrb_define_method(mrb, fl,      "/",         flo_div,        MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2273|  1.74k|  mrb_define_method(mrb, fl,      "quo",       flo_div,        MRB_ARGS_REQ(1)); /* 15.2.7.4.5(x) */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2274|  1.74k|  mrb_define_method(mrb, fl,      "div",       flo_idiv,       MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2275|  1.74k|  mrb_define_method(mrb, fl,      "+",         flo_add,        MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2276|  1.74k|  mrb_define_method(mrb, fl,      "-",         flo_sub,        MRB_ARGS_REQ(1)); /* 15.2.9.3.4 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2277|  1.74k|  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2278|  1.74k|  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2279|  1.74k|  mrb_define_method(mrb, fl,      "<=>",       num_cmp,        MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2280|  1.74k|  mrb_define_method(mrb, fl,      "<",         num_lt,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2281|  1.74k|  mrb_define_method(mrb, fl,      "<=",        num_le,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2282|  1.74k|  mrb_define_method(mrb, fl,      ">",         num_gt,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2283|  1.74k|  mrb_define_method(mrb, fl,      ">=",        num_ge,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2284|  1.74k|  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2285|  1.74k|  mrb_define_method(mrb, fl,      "~",         flo_rev,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2286|  1.74k|  mrb_define_method(mrb, fl,      "&",         flo_and,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2287|  1.74k|  mrb_define_method(mrb, fl,      "|",         flo_or,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2288|  1.74k|  mrb_define_method(mrb, fl,      "^",         flo_xor,        MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2289|  1.74k|  mrb_define_method(mrb, fl,      ">>",        flo_rshift,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2290|  1.74k|  mrb_define_method(mrb, fl,      "<<",        flo_lshift,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2291|  1.74k|  mrb_define_method(mrb, fl,      "ceil",      flo_ceil,       MRB_ARGS_OPT(1)); /* 15.2.9.3.8  */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2292|  1.74k|  mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.9  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2293|  1.74k|  mrb_define_method(mrb, fl,      "floor",     flo_floor,      MRB_ARGS_OPT(1)); /* 15.2.9.3.10 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2294|  1.74k|  mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2295|  1.74k|  mrb_define_method(mrb, fl,      "round",     flo_round,      MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2296|  1.74k|  mrb_define_method(mrb, fl,      "to_f",      flo_to_f,       MRB_ARGS_NONE()); /* 15.2.9.3.13 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2297|  1.74k|  mrb_define_method(mrb, fl,      "to_i",      flo_to_i,       MRB_ARGS_NONE()); /* 15.2.9.3.14 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2298|  1.74k|  mrb_define_method(mrb, fl,      "truncate",  flo_truncate,   MRB_ARGS_OPT(1)); /* 15.2.9.3.15 */
  ------------------
  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  ------------------
 2299|  1.74k|  mrb_define_method(mrb, fl,      "divmod",    flo_divmod,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 2300|       |
 2301|  1.74k|  mrb_define_method(mrb, fl,      "to_s",      flo_to_s,       MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2302|  1.74k|  mrb_define_method(mrb, fl,      "inspect",   flo_to_s,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2303|  1.74k|  mrb_define_method(mrb, fl,      "nan?",      flo_nan_p,      MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2304|  1.74k|  mrb_define_method(mrb, fl,      "abs",       flo_abs,        MRB_ARGS_NONE()); /* 15.2.7.4.3 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2305|  1.74k|  mrb_define_method(mrb, fl,      "hash",      flo_hash,       MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 2306|       |
 2307|  1.74k|#ifdef INFINITY
 2308|  1.74k|  mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2309|  1.74k|#endif
 2310|  1.74k|#ifdef NAN
 2311|  1.74k|  mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN));
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 2312|  1.74k|#endif
 2313|  1.74k|#endif
 2314|  1.74k|}
numeric.c:mrb_int_noconv:
   38|     14|{
   39|     14|  mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into Integer", y);
  ------------------
  |  | 1375|     14|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|     14|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     14|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   40|     14|}
numeric.c:flo_to_i:
 1049|    803|{
 1050|    803|  mrb_float f = mrb_float(num);
  ------------------
  |  |  155|    803|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1051|       |
 1052|    803|  mrb_check_num_exact(mrb, f);
 1053|    803|  if (!FIXABLE_FLOAT(f)) {
  ------------------
  |  |   27|    803|#define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
  |  |  ------------------
  |  |  |  Branch (27:27): [True: 793, False: 10]
  |  |  |  Branch (27:58): [True: 791, False: 2]
  |  |  ------------------
  ------------------
 1054|     12|#ifdef MRB_USE_BIGINT
 1055|     12|    return mrb_bint_new_float(mrb, f);
 1056|       |#else
 1057|       |    mrb_int_overflow(mrb, "to_f");
 1058|       |#endif
 1059|     12|  }
 1060|    791|  if (f > 0.0) f = floor(f);
  ------------------
  |  Branch (1060:7): [True: 394, False: 397]
  ------------------
 1061|    791|  if (f < 0.0) f = ceil(f);
  ------------------
  |  Branch (1061:7): [True: 61, False: 730]
  ------------------
 1062|       |
 1063|    791|  return mrb_int_value(mrb, (mrb_int)f);
 1064|    803|}
numeric.c:cmpnum:
 2023|  2.68k|{
 2024|  2.68k|#ifdef MRB_USE_BIGINT
 2025|  2.68k|  if (mrb_bigint_p(v1)) {
  ------------------
  |  |  314|  2.68k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 2.64k, False: 41]
  |  |  ------------------
  ------------------
 2026|  2.64k|    return mrb_bint_cmp(mrb, v1, v2);
 2027|  2.64k|  }
 2028|     41|#endif
 2029|       |
 2030|       |#ifdef MRB_NO_FLOAT
 2031|       |  mrb_int x, y;
 2032|       |#else
 2033|     41|  mrb_float x, y;
 2034|     41|#endif
 2035|       |
 2036|       |#ifdef MRB_NO_FLOAT
 2037|       |  x = mrb_integer(v1);
 2038|       |#else
 2039|     41|  x = mrb_as_float(mrb, v1);
  ------------------
  |  | 1297|     41|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|     41|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 2040|     41|#endif
 2041|     41|  switch (mrb_type(v2)) {
 2042|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (2042:3): [True: 0, False: 41]
  ------------------
 2043|       |#ifdef MRB_NO_FLOAT
 2044|       |    y = mrb_integer(v2);
 2045|       |#else
 2046|      0|    y = (mrb_float)mrb_integer(v2);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 2047|      0|#endif
 2048|      0|    break;
 2049|      0|#ifndef MRB_NO_FLOAT
 2050|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (2050:3): [True: 0, False: 41]
  ------------------
 2051|      0|    y = mrb_float(v2);
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 2052|      0|    break;
 2053|      0|#ifdef MRB_USE_RATIONAL
 2054|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (2054:3): [True: 0, False: 41]
  ------------------
 2055|      0|    y = mrb_as_float(mrb, v2);
  ------------------
  |  | 1297|      0|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 2056|      0|    break;
 2057|      0|#endif
 2058|      0|#endif
 2059|     41|  default:
  ------------------
  |  Branch (2059:3): [True: 41, False: 0]
  ------------------
 2060|     41|    return -2;
 2061|     41|  }
 2062|      0|  if (x > y)
  ------------------
  |  Branch (2062:7): [True: 0, False: 0]
  ------------------
 2063|      0|    return 1;
 2064|      0|  else {
 2065|      0|    if (x < y)
  ------------------
  |  Branch (2065:9): [True: 0, False: 0]
  ------------------
 2066|      0|      return -1;
 2067|      0|    return 0;
 2068|      0|  }
 2069|      0|}
numeric.c:num_lt:
 2115|    163|{
 2116|    163|  mrb_value other = mrb_get_arg1(mrb);
 2117|    163|  mrb_int n;
 2118|       |
 2119|    163|  n = cmpnum(mrb, self, other);
 2120|    163|  if (n == -2) cmperr(mrb, self, other);
  ------------------
  |  Branch (2120:7): [True: 13, False: 150]
  ------------------
 2121|    150|  if (n < 0) return mrb_true_value();
  ------------------
  |  Branch (2121:7): [True: 10, False: 140]
  ------------------
 2122|    140|  return mrb_false_value();
 2123|    150|}
numeric.c:cmperr:
 2109|     46|{
 2110|     46|  mrb_raisef(mrb, E_ARGUMENT_ERROR, "comparison of %t with %t failed", v1, v2);
  ------------------
  |  | 1377|     46|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|     46|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     46|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2111|     46|}
numeric.c:num_le:
 2127|  1.93k|{
 2128|  1.93k|  mrb_value other = mrb_get_arg1(mrb);
 2129|  1.93k|  mrb_int n;
 2130|       |
 2131|  1.93k|  n = cmpnum(mrb, self, other);
 2132|  1.93k|  if (n == -2) cmperr(mrb, self, other);
  ------------------
  |  Branch (2132:7): [True: 9, False: 1.92k]
  ------------------
 2133|  1.92k|  if (n <= 0) return mrb_true_value();
  ------------------
  |  Branch (2133:7): [True: 572, False: 1.35k]
  ------------------
 2134|  1.35k|  return mrb_false_value();
 2135|  1.92k|}
numeric.c:num_gt:
 2139|    336|{
 2140|    336|  mrb_value other = mrb_get_arg1(mrb);
 2141|    336|  mrb_int n;
 2142|       |
 2143|    336|  n = cmpnum(mrb, self, other);
 2144|    336|  if (n == -2) cmperr(mrb, self, other);
  ------------------
  |  Branch (2144:7): [True: 12, False: 324]
  ------------------
 2145|    324|  if (n > 0) return mrb_true_value();
  ------------------
  |  Branch (2145:7): [True: 265, False: 59]
  ------------------
 2146|     59|  return mrb_false_value();
 2147|    324|}
numeric.c:num_ge:
 2151|    250|{
 2152|    250|  mrb_value other = mrb_get_arg1(mrb);
 2153|    250|  mrb_int n;
 2154|       |
 2155|    250|  n = cmpnum(mrb, self, other);
 2156|    250|  if (n == -2) cmperr(mrb, self, other);
  ------------------
  |  Branch (2156:7): [True: 12, False: 238]
  ------------------
 2157|    238|  if (n >= 0) return mrb_true_value();
  ------------------
  |  Branch (2157:7): [True: 178, False: 60]
  ------------------
 2158|     60|  return mrb_false_value();
 2159|    238|}
numeric.c:int_add:
 1866|  5.02k|{
 1867|  5.02k|  mrb_value other = mrb_get_arg1(mrb);
 1868|       |
 1869|  5.02k|#ifdef MRB_USE_BIGINT
 1870|  5.02k|  if (mrb_bigint_p(self)) {
  ------------------
  |  |  314|  5.02k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 3.39k, False: 1.63k]
  |  |  ------------------
  ------------------
 1871|  3.39k|    return mrb_bint_add(mrb, self, other);
 1872|  3.39k|  }
 1873|  1.63k|#endif
 1874|  1.63k|  return mrb_int_add(mrb, self, other);
 1875|  5.02k|}
numeric.c:int_sub:
 1930|  5.11k|{
 1931|  5.11k|  mrb_value other = mrb_get_arg1(mrb);
 1932|       |
 1933|  5.11k|#ifdef MRB_USE_BIGINT
 1934|  5.11k|  if (mrb_bigint_p(self)) {
  ------------------
  |  |  314|  5.11k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 2.27k, False: 2.84k]
  |  |  ------------------
  ------------------
 1935|  2.27k|    return mrb_bint_sub(mrb, self, other);
 1936|  2.27k|  }
 1937|  2.84k|#endif
 1938|  2.84k|  return mrb_int_sub(mrb, self, other);
 1939|  5.11k|}
numeric.c:int_mul:
 1184|  3.51k|{
 1185|  3.51k|  mrb_value y = mrb_get_arg1(mrb);
 1186|       |
 1187|  3.51k|#ifdef MRB_USE_BIGINT
 1188|  3.51k|  if (mrb_bigint_p(x)) {
  ------------------
  |  |  314|  3.51k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 2.32k, False: 1.19k]
  |  |  ------------------
  ------------------
 1189|  2.32k|    return mrb_bint_mul(mrb, x, y);
 1190|  2.32k|  }
 1191|  1.19k|#endif
 1192|  1.19k|  return mrb_int_mul(mrb, x, y);
 1193|  3.51k|}
numeric.c:int_mod:
 1228|  5.69k|{
 1229|  5.69k|  mrb_value y = mrb_get_arg1(mrb);
 1230|  5.69k|  mrb_int a, b;
 1231|       |
 1232|  5.69k|#ifdef MRB_USE_BIGINT
 1233|  5.69k|  if (mrb_bigint_p(x)) {
  ------------------
  |  |  314|  5.69k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 2.61k, False: 3.08k]
  |  |  ------------------
  ------------------
 1234|  2.61k|    return mrb_bint_mod(mrb, x, y);
 1235|  2.61k|  }
 1236|  3.08k|#endif
 1237|  3.08k|  a = mrb_integer(x);
  ------------------
  |  |  166|  3.08k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1238|  3.08k|  if (a == 0) return x;
  ------------------
  |  Branch (1238:7): [True: 434, False: 2.65k]
  ------------------
 1239|  2.65k|  if (mrb_integer_p(y)) {
  ------------------
  |  |  171|  2.65k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  5.30k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 748, False: 1.90k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  1.90k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.80k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.80k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 554, False: 1.34k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.34k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 240, False: 1.10k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1240|    988|    b = mrb_integer(y);
  ------------------
  |  |  166|    988|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1241|    988|    if (b == 0) mrb_int_zerodiv(mrb);
  ------------------
  |  Branch (1241:9): [True: 20, False: 968]
  ------------------
 1242|    968|    if (a == MRB_INT_MIN && b == -1) return mrb_fixnum_value(0);
  ------------------
  |  |   81|  1.93k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (1242:9): [True: 76, False: 892]
  |  Branch (1242:29): [True: 4, False: 72]
  ------------------
 1243|    964|    mrb_int mod = a % b;
 1244|    964|    if ((a < 0) != (b < 0) && mod != 0) {
  ------------------
  |  Branch (1244:9): [True: 604, False: 360]
  |  Branch (1244:31): [True: 431, False: 173]
  ------------------
 1245|    431|      mod += b;
 1246|    431|    }
 1247|    964|    return mrb_int_value(mrb, mod);
 1248|    968|  }
 1249|       |#ifdef MRB_NO_FLOAT
 1250|       |  mrb_raise(mrb, E_TYPE_ERROR, "non integer modulo");
 1251|       |#else
 1252|  1.66k|  mrb_float mod;
 1253|       |
 1254|  1.66k|  flodivmod(mrb, (mrb_float)a, mrb_as_float(mrb, y), NULL, &mod);
  ------------------
  |  | 1297|  1.66k|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|  1.66k|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
 1255|  1.66k|  return mrb_float_value(mrb, mod);
 1256|  2.65k|#endif
 1257|  2.65k|}
numeric.c:flodivmod:
  484|  2.68k|{
  485|  2.68k|  double div, mod;
  486|       |
  487|  2.68k|  if (isnan(y)) {
  488|       |    /* y is NaN so all results are NaN */
  489|    315|    div = mod = y;
  490|    315|    goto exit;
  491|    315|  }
  492|  2.37k|  if (y == 0.0) {
  ------------------
  |  Branch (492:7): [True: 4, False: 2.37k]
  ------------------
  493|      4|    mrb_int_zerodiv(mrb);
  494|      4|  }
  495|  2.37k|  if (isinf(y) && !isinf(x)) {
  ------------------
  |  Branch (495:19): [True: 93, False: 4]
  ------------------
  496|     93|    mod = x;
  497|     93|  }
  498|  2.27k|  else {
  499|  2.27k|    mod = fmod(x, y);
  500|  2.27k|  }
  501|  2.37k|  if (isinf(x) && !isinf(y)) {
  ------------------
  |  Branch (501:19): [True: 101, False: 4]
  ------------------
  502|    101|    div = x;
  503|    101|  }
  504|  2.26k|  else {
  505|  2.26k|    div = (x - mod) / y;
  506|  2.26k|    if (modp && divp) div = round(div);
  ------------------
  |  Branch (506:9): [True: 2.26k, False: 0]
  |  Branch (506:17): [True: 0, False: 2.26k]
  ------------------
  507|  2.26k|  }
  508|  2.37k|  if (div == 0) div = 0.0;
  ------------------
  |  Branch (508:7): [True: 1.46k, False: 903]
  ------------------
  509|  2.37k|  if (mod == 0) mod = 0.0;
  ------------------
  |  Branch (509:7): [True: 567, False: 1.80k]
  ------------------
  510|  2.37k|  if (y*mod < 0) {
  ------------------
  |  Branch (510:7): [True: 533, False: 1.83k]
  ------------------
  511|    533|    mod += y;
  512|    533|    div -= 1.0;
  513|    533|  }
  514|  2.68k| exit:
  515|  2.68k|  if (modp) *modp = mod;
  ------------------
  |  Branch (515:7): [True: 2.68k, False: 0]
  ------------------
  516|  2.68k|  if (divp) *divp = div;
  ------------------
  |  Branch (516:7): [True: 0, False: 2.68k]
  ------------------
  517|  2.68k|}
numeric.c:int_div:
  154|  3.75k|{
  155|  3.75k|  mrb_value y = mrb_get_arg1(mrb);
  156|  3.75k|#ifdef MRB_USE_BIGINT
  157|  3.75k|  if (mrb_bigint_p(x)) {
  ------------------
  |  |  314|  3.75k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 2.08k, False: 1.67k]
  |  |  ------------------
  ------------------
  158|  2.08k|    return mrb_bint_div(mrb, x, y);
  159|  2.08k|  }
  160|  1.67k|#endif
  161|  1.67k| mrb_int a = mrb_integer(x);
  ------------------
  |  |  166|  1.67k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  162|       |
  163|  1.67k|  if (mrb_integer_p(y)) {
  ------------------
  |  |  171|  1.67k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  3.34k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 1.67k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  1.67k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.34k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.34k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 3, False: 1.67k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.67k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 1.67k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|      0|    return mrb_div_int_value(mrb, a, mrb_integer(y));
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  165|      0|  }
  166|  1.67k|  switch (mrb_type(y)) {
  167|      0|#ifdef MRB_USE_BIGINT
  168|  1.67k|  case MRB_TT_BIGINT:
  ------------------
  |  Branch (168:3): [True: 1.67k, False: 3]
  ------------------
  169|  1.67k|    return mrb_bint_div(mrb, mrb_bint_new_int(mrb, a), y);
  170|      0|#endif
  171|      0|#ifdef MRB_USE_RATIONAL
  172|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (172:3): [True: 0, False: 1.67k]
  ------------------
  173|      0|    return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y);
  174|      0|#endif
  175|      0|#ifdef MRB_USE_COMPLEX
  176|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (176:3): [True: 0, False: 1.67k]
  ------------------
  177|      0|    x = mrb_complex_new(mrb, (mrb_float)a, 0);
  178|      0|    return mrb_complex_div(mrb, x, y);
  179|      0|#endif
  180|      0|#ifndef MRB_NO_FLOAT
  181|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (181:3): [True: 0, False: 1.67k]
  ------------------
  182|      0|    return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y)));
  ------------------
  |  | 1297|      0|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  183|      0|#endif
  184|      3|  default:
  ------------------
  |  Branch (184:3): [True: 3, False: 1.67k]
  ------------------
  185|      3|    mrb_int_noconv(mrb, y);
  186|  1.67k|  }
  187|  1.67k|}
numeric.c:int_equal:
 1330|  63.0k|{
 1331|  63.0k|  mrb_value y = mrb_get_arg1(mrb);
 1332|       |
 1333|  63.0k|  switch (mrb_type(y)) {
 1334|  59.2k|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (1334:3): [True: 59.2k, False: 3.85k]
  ------------------
 1335|  59.2k|    return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
  ------------------
  |  |  166|  59.2k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
                  return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
  ------------------
  |  |  166|  59.2k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1336|      0|#ifndef MRB_NO_FLOAT
 1337|     71|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (1337:3): [True: 71, False: 63.0k]
  ------------------
 1338|     71|    return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y));
  ------------------
  |  |  166|     71|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
                  return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y));
  ------------------
  |  |  155|     71|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 1339|      0|#endif
 1340|      0|#ifdef MRB_USE_BIGINT
 1341|    936|  case MRB_TT_BIGINT:
  ------------------
  |  Branch (1341:3): [True: 936, False: 62.1k]
  ------------------
 1342|    936|    return mrb_bool_value(mrb_bint_cmp(mrb, y, x) == 0);
 1343|      0|#endif
 1344|      0|#ifdef MRB_USE_RATIONAL
 1345|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (1345:3): [True: 0, False: 63.0k]
  ------------------
 1346|      0|    return mrb_bool_value(mrb_equal(mrb, y, x));
 1347|      0|#endif
 1348|      0|#ifdef MRB_USE_COMPLEX
 1349|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (1349:3): [True: 0, False: 63.0k]
  ------------------
 1350|      0|    return mrb_bool_value(mrb_equal(mrb, y, x));
 1351|      0|#endif
 1352|  2.84k|  default:
  ------------------
  |  Branch (1352:3): [True: 2.84k, False: 60.2k]
  ------------------
 1353|  2.84k|    return mrb_false_value();
 1354|  63.0k|  }
 1355|  63.0k|}
numeric.c:int_xor:
 1452|  4.56k|{
 1453|  4.56k|  mrb_value y = mrb_get_arg1(mrb);
 1454|       |
 1455|  4.56k|#ifdef MRB_USE_BIGINT
 1456|  4.56k|  if (mrb_bigint_p(x)) {
  ------------------
  |  |  314|  4.56k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 2.05k, False: 2.51k]
  |  |  ------------------
  ------------------
 1457|  2.05k|    return mrb_bint_xor(mrb, x, y);
 1458|  2.05k|  }
 1459|  2.51k|  if (mrb_bigint_p(y)) {
  ------------------
  |  |  314|  2.51k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 1.21k, False: 1.29k]
  |  |  ------------------
  ------------------
 1460|  1.21k|    return mrb_bint_xor(mrb, mrb_as_bint(mrb, x), y);
 1461|  1.21k|  }
 1462|  1.29k|#endif
 1463|  1.29k|  bit_op(x, y, or, ^);
  ------------------
  |  | 1388|  1.29k|#define bit_op(x,y,op1,op2) do {\
  |  | 1389|  1.29k|  if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \
  |  |  ------------------
  |  |  |  |  171|  1.29k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  |  |  ------------------
  |  |  |  |  |  |   76|  2.59k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (76:3): [True: 1.00k, False: 290]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  |  |  ------------------
  |  |  |  |  |  |   78|    290|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  148|    580|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   71|    580|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (148:29): [True: 216, False: 74]
  |  |  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 74]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (78:27): [True: 74, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \
  |  |  ------------------
  |  |  |  |  166|  1.07k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  |  |                 if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \
  |  |  ------------------
  |  |  |  |  166|  1.07k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  |  | 1390|  1.29k|  return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_integer(x)));\
  |  |  ------------------
  |  |  |  |  166|    216|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  |  | 1391|  1.29k|} while(0)
  |  |  ------------------
  |  |  |  Branch (1391:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1464|  1.29k|}
numeric.c:int_rshift:
 1549|  6.81k|{
 1550|  6.81k|  mrb_int width, val;
 1551|       |
 1552|  6.81k|  width = mrb_as_int(mrb, mrb_get_arg1(mrb));
  ------------------
  |  | 1425|  6.81k|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|  6.81k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
 1553|  6.81k|  if (width == 0) {
  ------------------
  |  Branch (1553:7): [True: 629, False: 6.18k]
  ------------------
 1554|    629|    return x;
 1555|    629|  }
 1556|  6.18k|  if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift");
  ------------------
  |  |   81|  6.18k|# define MRB_INT_MIN INT64_MIN
  ------------------
  |  Branch (1556:7): [True: 2, False: 6.17k]
  ------------------
 1557|  6.17k|#ifdef MRB_USE_BIGINT
 1558|  6.17k|  if (mrb_bigint_p(x)) {
  ------------------
  |  |  314|  6.17k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 834, False: 5.34k]
  |  |  ------------------
  ------------------
 1559|    834|    return mrb_bint_rshift(mrb, x, width);
 1560|    834|  }
 1561|  5.34k|#endif
 1562|  5.34k|  val = mrb_integer(x);
  ------------------
  |  |  166|  5.34k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1563|  5.34k|  if (val == 0) return x;
  ------------------
  |  Branch (1563:7): [True: 312, False: 5.03k]
  ------------------
 1564|  5.03k|  if (!mrb_num_shift(mrb, val, -width, &val)) {
  ------------------
  |  Branch (1564:7): [True: 2.70k, False: 2.33k]
  ------------------
 1565|  2.70k|#ifdef MRB_USE_BIGINT
 1566|  2.70k|    return mrb_bint_rshift(mrb, mrb_bint_new_int(mrb, val), width);
 1567|       |#else
 1568|       |    mrb_int_overflow(mrb, "bit shift");
 1569|       |#endif
 1570|  2.70k|  }
 1571|  2.33k|  return mrb_int_value(mrb, val);
 1572|  5.03k|}
numeric.c:int_to_s:
 2013|      1|{
 2014|      1|  mrb_int base = 10;
 2015|       |
 2016|      1|  mrb_get_args(mrb, "|i", &base);
 2017|      1|  return mrb_integer_to_str(mrb, self, base);
 2018|      1|}
numeric.c:flo_div:
  322|    311|{
  323|    311|  mrb_value y = mrb_get_arg1(mrb);
  324|    311|  mrb_float a = mrb_float(x);
  ------------------
  |  |  155|    311|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  325|       |
  326|    311|  switch(mrb_type(y)) {
  327|      0|#ifdef MRB_USE_COMPLEX
  328|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (328:3): [True: 0, False: 311]
  ------------------
  329|      0|    return mrb_complex_div(mrb, mrb_complex_new(mrb, a, 0), y);
  330|      0|#endif
  331|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (331:3): [True: 0, False: 311]
  ------------------
  332|      0|    a = mrb_div_float(a, mrb_float(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  333|      0|    return mrb_float_value(mrb, a);
  334|    311|  default:
  ------------------
  |  Branch (334:3): [True: 311, False: 0]
  ------------------
  335|    311|    a = mrb_div_float(a, mrb_as_float(mrb, y));
  ------------------
  |  | 1297|    311|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|    311|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  336|    311|    return mrb_float_value(mrb, a);
  337|    311|  }
  338|      0|  return mrb_float_value(mrb, a);
  339|    311|}
numeric.c:flo_add:
  412|    134|{
  413|    134|  mrb_value y = mrb_get_arg1(mrb);
  414|    134|  mrb_float a = mrb_float(x);
  ------------------
  |  |  155|    134|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  415|       |
  416|    134|  switch (mrb_type(y)) {
  417|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (417:3): [True: 0, False: 134]
  ------------------
  418|      0|    return mrb_float_value(mrb, a + mrb_float(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  419|      0|#if defined(MRB_USE_COMPLEX)
  420|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (420:3): [True: 0, False: 134]
  ------------------
  421|      0|    return mrb_complex_add(mrb, y, x);
  422|      0|#endif
  423|    134|  default:
  ------------------
  |  Branch (423:3): [True: 134, False: 0]
  ------------------
  424|    134|    return mrb_float_value(mrb, a + mrb_as_float(mrb, y));
  ------------------
  |  | 1297|    134|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|    134|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  425|    134|  }
  426|    134|}
numeric.c:flo_sub:
  439|     84|{
  440|     84|  mrb_value y = mrb_get_arg1(mrb);
  441|     84|  mrb_float a = mrb_float(x);
  ------------------
  |  |  155|     84|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  442|       |
  443|     84|  switch (mrb_type(y)) {
  444|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (444:3): [True: 0, False: 84]
  ------------------
  445|      0|    return mrb_float_value(mrb, a - mrb_float(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  446|      0|#if defined(MRB_USE_COMPLEX)
  447|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (447:3): [True: 0, False: 84]
  ------------------
  448|      0|    return mrb_complex_sub(mrb, mrb_complex_new(mrb, a, 0), y);
  449|      0|#endif
  450|     84|  default:
  ------------------
  |  Branch (450:3): [True: 84, False: 0]
  ------------------
  451|     84|    return mrb_float_value(mrb, a - mrb_as_float(mrb, y));
  ------------------
  |  | 1297|     84|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|     84|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  452|     84|  }
  453|     84|}
numeric.c:flo_mul:
  466|    285|{
  467|    285|  mrb_value y = mrb_get_arg1(mrb);
  468|    285|  mrb_float a = mrb_float(x);
  ------------------
  |  |  155|    285|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  469|       |
  470|    285|  switch (mrb_type(y)) {
  471|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (471:3): [True: 0, False: 285]
  ------------------
  472|      0|    return mrb_float_value(mrb, a * mrb_float(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  473|      0|#if defined(MRB_USE_COMPLEX)
  474|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (474:3): [True: 0, False: 285]
  ------------------
  475|      0|    return mrb_complex_mul(mrb, y, x);
  476|      0|#endif
  477|    285|  default:
  ------------------
  |  Branch (477:3): [True: 285, False: 0]
  ------------------
  478|    285|    return mrb_float_value(mrb, a * mrb_as_float(mrb, y));
  ------------------
  |  | 1297|    285|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|    285|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  479|    285|  }
  480|    285|}
numeric.c:flo_mod:
  533|  1.02k|{
  534|  1.02k|  mrb_value y = mrb_get_arg1(mrb);
  535|  1.02k|  mrb_float mod;
  536|       |
  537|  1.02k|  flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), NULL, &mod);
  ------------------
  |  |  155|  1.02k|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
                flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), NULL, &mod);
  ------------------
  |  | 1297|  1.02k|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|  1.02k|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  538|  1.02k|  return mrb_float_value(mrb, mod);
  539|  1.02k|}
numeric.c:flo_eq:
  593|    125|{
  594|    125|  mrb_value y = mrb_get_arg1(mrb);
  595|       |
  596|    125|  switch (mrb_type(y)) {
  597|      0|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (597:3): [True: 0, False: 125]
  ------------------
  598|      0|    return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
                  return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  599|      0|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (599:3): [True: 0, False: 125]
  ------------------
  600|      0|    return mrb_bool_value(mrb_float(x) == mrb_float(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
                  return mrb_bool_value(mrb_float(x) == mrb_float(y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  601|      0|#ifdef MRB_USE_RATIONAL
  602|      0|  case MRB_TT_RATIONAL:
  ------------------
  |  Branch (602:3): [True: 0, False: 125]
  ------------------
  603|      0|    return mrb_bool_value(mrb_float(x) == mrb_as_float(mrb, y));
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
                  return mrb_bool_value(mrb_float(x) == mrb_as_float(mrb, y));
  ------------------
  |  | 1297|      0|#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x))
  |  |  ------------------
  |  |  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  ------------------
  ------------------
  604|      0|#endif
  605|      0|#ifdef MRB_USE_COMPLEX
  606|      0|  case MRB_TT_COMPLEX:
  ------------------
  |  Branch (606:3): [True: 0, False: 125]
  ------------------
  607|      0|    return mrb_bool_value(mrb_equal(mrb, y, x));
  608|      0|#endif
  609|    125|  default:
  ------------------
  |  Branch (609:3): [True: 125, False: 0]
  ------------------
  610|    125|    return mrb_false_value();
  611|    125|  }
  612|    125|}
numeric.c:value_int64:
  616|  1.02k|{
  617|  1.02k|  switch (mrb_type(x)) {
  618|    267|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (618:3): [True: 267, False: 758]
  ------------------
  619|    267|    return (int64_t)mrb_integer(x);
  ------------------
  |  |  166|    267|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  620|    749|  case MRB_TT_FLOAT:
  ------------------
  |  Branch (620:3): [True: 749, False: 276]
  ------------------
  621|    749|    {
  622|    749|      double f = mrb_float(x);
  ------------------
  |  |  155|    749|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  623|       |
  624|    749|      if ((mrb_float)INT64_MAX >= f && f >= (mrb_float)INT64_MIN)
  ------------------
  |  Branch (624:11): [True: 745, False: 4]
  |  Branch (624:40): [True: 745, False: 0]
  ------------------
  625|    745|        return (int64_t)f;
  626|    749|    }
  627|     13|  default:
  ------------------
  |  Branch (627:3): [True: 9, False: 1.01k]
  ------------------
  628|     13|    mrb_raise(mrb, E_TYPE_ERROR, "cannot convert to Integer");
  ------------------
  |  | 1375|     13|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|     13|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     13|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  629|      0|    break;
  630|  1.02k|  }
  631|       |  /* not reached */
  632|      0|  return 0;
  633|  1.02k|}
numeric.c:int64_value:
  637|    501|{
  638|    501|  if (!TYPED_FIXABLE(v,int64_t)) {
  ------------------
  |  |   21|    501|#define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
  |  |  ------------------
  |  |  |  |   19|  1.00k|#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
  |  |  |  |  ------------------
  |  |  |  |  |  |   42|    501|# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   36|    501|#define MRB_FIXNUM_SHIFT        WORDBOX_FIXNUM_SHIFT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    501|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   48|    501|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:31): [True: 499, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
  |  |  ------------------
  |  |  |  |   20|    499|#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
  |  |  |  |  ------------------
  |  |  |  |  |  |   41|    499|# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   36|    499|#define MRB_FIXNUM_SHIFT        WORDBOX_FIXNUM_SHIFT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    499|#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   48|    499|#define WORDBOX_FIXNUM_BIT_POS  1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (20:31): [True: 497, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  639|      4|    mrb_int_overflow(mrb, "bit operation");
  640|      4|  }
  641|    497|  return mrb_fixnum_value((mrb_int)v);
  642|    501|}
numeric.c:flo_or:
  664|    216|{
  665|    216|  mrb_value y = mrb_get_arg1(mrb);
  666|    216|  int64_t v1, v2;
  667|       |
  668|    216|  v1 = value_int64(mrb, x);
  669|    216|  v2 = value_int64(mrb, y);
  670|    216|  return int64_value(mrb, v1 | v2);
  671|    216|}
numeric.c:flo_xor:
  675|    298|{
  676|    298|  mrb_value y = mrb_get_arg1(mrb);
  677|    298|  int64_t v1, v2;
  678|       |
  679|    298|  v1 = value_int64(mrb, x);
  680|    298|  v2 = value_int64(mrb, y);
  681|    298|  return int64_value(mrb, v1 ^ v2);
  682|    298|}
numeric.c:flo_rshift:
  731|  1.25k|{
  732|  1.25k|  mrb_int width = mrb_as_int(mrb, mrb_get_arg1(mrb));
  ------------------
  |  | 1425|  1.25k|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|  1.25k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
  733|  1.25k|  if (width == MRB_INT_MIN) return flo_shift(mrb, x, -MRB_INT_BIT);
  ------------------
  |  |   81|  1.25k|# define MRB_INT_MIN INT64_MIN
  ------------------
                if (width == MRB_INT_MIN) return flo_shift(mrb, x, -MRB_INT_BIT);
  ------------------
  |  |   80|      3|# define MRB_INT_BIT 64
  ------------------
  |  Branch (733:7): [True: 3, False: 1.25k]
  ------------------
  734|  1.25k|  return flo_shift(mrb, x, -width);
  735|  1.25k|}
numeric.c:flo_shift:
  686|  1.25k|{
  687|  1.25k|  mrb_float val;
  688|       |
  689|  1.25k|  if (width == 0) {
  ------------------
  |  Branch (689:7): [True: 344, False: 906]
  ------------------
  690|    344|    return x;
  691|    344|  }
  692|    906|  val = mrb_float(x);
  ------------------
  |  |  155|    906|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  693|    906|  if (width < -MRB_INT_BIT/2) {
  ------------------
  |  |   80|    906|# define MRB_INT_BIT 64
  ------------------
  |  Branch (693:7): [True: 184, False: 722]
  ------------------
  694|    184|    if (val < 0) return mrb_fixnum_value(-1);
  ------------------
  |  Branch (694:9): [True: 47, False: 137]
  ------------------
  695|    137|    return mrb_fixnum_value(0);
  696|    184|  }
  697|    722|  if (width < 0) {
  ------------------
  |  Branch (697:7): [True: 651, False: 71]
  ------------------
  698|    860|    while (width++) {
  ------------------
  |  Branch (698:12): [True: 708, False: 152]
  ------------------
  699|    708|      val /= 2;
  700|    708|      if (val < 1.0) {
  ------------------
  |  Branch (700:11): [True: 499, False: 209]
  ------------------
  701|    499|        val = 0;
  702|    499|        break;
  703|    499|      }
  704|    708|    }
  705|       |#if defined(_ISOC99_SOURCE)
  706|       |    val = trunc(val);
  707|       |#else
  708|    651|    if (val > 0){
  ------------------
  |  Branch (708:9): [True: 113, False: 538]
  ------------------
  709|    113|      val = floor(val);
  710|    113|    }
  711|    538|    else {
  712|    538|      val = ceil(val);
  713|    538|    }
  714|    651|#endif
  715|    651|    if (val == 0 && mrb_float(x) < 0) {
  ------------------
  |  |  155|    499|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  |  Branch (715:9): [True: 499, False: 152]
  |  Branch (715:21): [True: 59, False: 440]
  ------------------
  716|     59|      return mrb_fixnum_value(-1);
  717|     59|    }
  718|    651|  }
  719|     71|  else {
  720|  4.90k|    while (width--) {
  ------------------
  |  Branch (720:12): [True: 4.83k, False: 71]
  ------------------
  721|  4.83k|      val *= 2;
  722|  4.83k|    }
  723|     71|  }
  724|    663|  if (FIXABLE_FLOAT(val))
  ------------------
  |  |   27|    663|#define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
  |  |  ------------------
  |  |  |  Branch (27:27): [True: 619, False: 44]
  |  |  |  Branch (27:58): [True: 552, False: 67]
  |  |  ------------------
  ------------------
  725|    552|    return mrb_int_value(mrb, (mrb_int)val);
  726|    111|  return mrb_float_value(mrb, val);
  727|    663|}
numeric.c:flo_to_s:
  383|      4|{
  384|      4|  mrb_float f = mrb_float(flt);
  ------------------
  |  |  155|      4|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  385|      4|  mrb_value str;
  386|       |
  387|      4|  if (isinf(f)) {
  388|      0|    str = f < 0 ? mrb_str_new_lit(mrb, "-Infinity")
  ------------------
  |  | 1209|      0|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  |  Branch (388:11): [True: 0, False: 0]
  ------------------
  389|      0|                : mrb_str_new_lit(mrb, "Infinity");
  ------------------
  |  | 1209|      0|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  390|      0|  }
  391|      4|  else if (isnan(f)) {
  392|      3|    str = mrb_str_new_lit(mrb, "NaN");
  ------------------
  |  | 1209|      3|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|      3|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
  393|      3|  }
  394|      1|  else {
  395|      1|    str = mrb_float_to_str(mrb, flt, NULL);
  396|      1|  }
  397|       |
  398|      4|  RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
  ------------------
  |  |   89|      4|# define RSTR_SET_ASCII_FLAG(s) (void)0
  ------------------
  399|      4|  return str;
  400|      4|}

mrb_obj_eq:
   17|   167k|{
   18|       |#if defined(MRB_NAN_BOXING)
   19|       |  return v1.u == v2.u;
   20|       |#elif defined(MRB_WORD_BOXING)
   21|   167k|  return v1.w == v2.w;
   22|       |#else  /* MRB_NO_BOXING */
   23|       |  if (mrb_type(v1) != mrb_type(v2)) return FALSE;
   24|       |  switch (mrb_type(v1)) {
   25|       |  case MRB_TT_TRUE:
   26|       |    return TRUE;
   27|       |
   28|       |  case MRB_TT_FALSE:
   29|       |    return (mrb_fixnum(v1) == mrb_fixnum(v2));
   30|       |  case MRB_TT_INTEGER:
   31|       |    return (mrb_integer(v1) == mrb_integer(v2));
   32|       |  case MRB_TT_SYMBOL:
   33|       |    return (mrb_symbol(v1) == mrb_symbol(v2));
   34|       |
   35|       |#ifndef MRB_NO_FLOAT
   36|       |  case MRB_TT_FLOAT:
   37|       |    return (mrb_float(v1) == mrb_float(v2));
   38|       |#endif
   39|       |
   40|       |  default:
   41|       |    return (mrb_ptr(v1) == mrb_ptr(v2));
   42|       |  }
   43|       |#endif
   44|   167k|}
mrb_obj_equal:
   48|  26.3k|{
   49|       |  /* temporary definition */
   50|  26.3k|  return mrb_obj_eq(mrb, v1, v2);
   51|  26.3k|}
mrb_equal:
   55|  60.2k|{
   56|  60.2k|  mrb_value result;
   57|       |
   58|  60.2k|  if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
  ------------------
  |  |   54|  1.18k|#  define TRUE 1
  ------------------
  |  Branch (58:7): [True: 1.18k, False: 59.0k]
  ------------------
   59|  59.0k|#ifndef MRB_NO_FLOAT
   60|       |  /* value mixing with integer and float */
   61|  59.0k|  if (mrb_integer_p(obj1) && mrb_float_p(obj2)) {
  ------------------
  |  |  171|   118k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|   118k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 59.0k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (mrb_integer_p(obj1) && mrb_float_p(obj2)) {
  ------------------
  |  |  179|  59.0k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|  59.0k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 16, False: 59.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|     16|    if ((mrb_float)mrb_integer(obj1) == mrb_float(obj2))
  ------------------
  |  |  166|     16|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
                  if ((mrb_float)mrb_integer(obj1) == mrb_float(obj2))
  ------------------
  |  |  155|     16|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
  |  Branch (62:9): [True: 0, False: 16]
  ------------------
   63|      0|      return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
   64|     16|    return FALSE;
  ------------------
  |  |   51|     16|#  define FALSE 0
  ------------------
   65|     16|  }
   66|  59.0k|  else if (mrb_float_p(obj1) && mrb_integer_p(obj2)) {
  ------------------
  |  |  179|  59.0k|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|   118k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 59.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                else if (mrb_float_p(obj1) && mrb_integer_p(obj2)) {
  ------------------
  |  |  171|      0|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   67|      0|    if (mrb_float(obj1) == (mrb_float)mrb_integer(obj2))
  ------------------
  |  |  155|      0|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
                  if (mrb_float(obj1) == (mrb_float)mrb_integer(obj2))
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  |  Branch (67:9): [True: 0, False: 0]
  ------------------
   68|      0|      return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
   69|      0|    return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
   70|      0|  }
   71|  59.0k|#endif
   72|  59.0k|#ifdef MRB_USE_BIGINT
   73|  59.0k|  if (mrb_bigint_p(obj1) &&
  ------------------
  |  |  314|   118k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 0, False: 59.0k]
  |  |  ------------------
  ------------------
   74|  59.0k|      (mrb_integer_p(obj2) || mrb_bigint_p(obj2) || mrb_float_p(obj2))) {
  ------------------
  |  |  171|      0|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                    (mrb_integer_p(obj2) || mrb_bigint_p(obj2) || mrb_float_p(obj2))) {
  ------------------
  |  |  314|      0|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                    (mrb_integer_p(obj2) || mrb_bigint_p(obj2) || mrb_float_p(obj2))) {
  ------------------
  |  |  179|      0|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   75|      0|    if (mrb_bint_cmp(mrb, obj1, obj2) == 0)
  ------------------
  |  Branch (75:9): [True: 0, False: 0]
  ------------------
   76|      0|      return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
   77|      0|    return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
   78|      0|  }
   79|  59.0k|#endif
   80|  59.0k|  result = mrb_funcall_id(mrb, obj1, MRB_OPSYM(eq), 1, obj2);
  ------------------
  |  |   12|  59.0k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  ------------------
   81|  59.0k|  if (mrb_test(result)) return TRUE;
  ------------------
  |  |  312|  59.0k|#define mrb_test(o)   mrb_bool(o)
  |  |  ------------------
  |  |  |  |  168|  59.0k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (168:24): [True: 0, False: 59.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (mrb_test(result)) return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
   82|  59.0k|  return FALSE;
  ------------------
  |  |   51|  59.0k|#  define FALSE 0
  ------------------
   83|  59.0k|}
mrb_init_object:
  303|  1.74k|{
  304|  1.74k|  struct RClass *n;
  305|  1.74k|  struct RClass *t;
  306|  1.74k|  struct RClass *f;
  307|       |
  308|  1.74k|  mrb->nil_class   = n = mrb_define_class(mrb, "NilClass",   mrb->object_class);
  309|  1.74k|  MRB_SET_INSTANCE_TT(n, MRB_TT_FALSE);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  310|  1.74k|  mrb_undef_class_method(mrb, n, "new");
  311|  1.74k|  mrb_define_method(mrb, n, "&",    false_and,      MRB_ARGS_REQ(1));  /* 15.2.4.3.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  312|  1.74k|  mrb_define_method(mrb, n, "^",    false_xor,      MRB_ARGS_REQ(1));  /* 15.2.4.3.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  313|  1.74k|  mrb_define_method(mrb, n, "|",    false_or,       MRB_ARGS_REQ(1));  /* 15.2.4.3.3  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  314|  1.74k|  mrb_define_method(mrb, n, "nil?", mrb_true,       MRB_ARGS_NONE());  /* 15.2.4.3.4  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  315|  1.74k|  mrb_define_method(mrb, n, "to_s", nil_to_s,       MRB_ARGS_NONE());  /* 15.2.4.3.5  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  316|  1.74k|  mrb_define_method(mrb, n, "inspect", nil_inspect, MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  317|       |
  318|  1.74k|  mrb->true_class  = t = mrb_define_class(mrb, "TrueClass",  mrb->object_class);
  319|  1.74k|  MRB_SET_INSTANCE_TT(t, MRB_TT_TRUE);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  320|  1.74k|  mrb_undef_class_method(mrb, t, "new");
  321|  1.74k|  mrb_define_method(mrb, t, "&",    true_and,       MRB_ARGS_REQ(1));  /* 15.2.5.3.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  322|  1.74k|  mrb_define_method(mrb, t, "^",    true_xor,       MRB_ARGS_REQ(1));  /* 15.2.5.3.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  323|  1.74k|  mrb_define_method(mrb, t, "to_s", true_to_s,      MRB_ARGS_NONE());  /* 15.2.5.3.3  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  324|  1.74k|  mrb_define_method(mrb, t, "|",    true_or,        MRB_ARGS_REQ(1));  /* 15.2.5.3.4  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  325|  1.74k|  mrb_define_method(mrb, t, "inspect", true_to_s,   MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  326|       |
  327|  1.74k|  mrb->false_class = f = mrb_define_class(mrb, "FalseClass", mrb->object_class);
  328|  1.74k|  MRB_SET_INSTANCE_TT(f, MRB_TT_FALSE);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  329|  1.74k|  mrb_undef_class_method(mrb, f, "new");
  330|  1.74k|  mrb_define_method(mrb, f, "&",    false_and,      MRB_ARGS_REQ(1));  /* 15.2.6.3.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  331|  1.74k|  mrb_define_method(mrb, f, "^",    false_xor,      MRB_ARGS_REQ(1));  /* 15.2.6.3.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  332|  1.74k|  mrb_define_method(mrb, f, "to_s", false_to_s,     MRB_ARGS_NONE());  /* 15.2.6.3.3  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  333|  1.74k|  mrb_define_method(mrb, f, "|",    false_or,       MRB_ARGS_REQ(1));  /* 15.2.6.3.4  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  334|  1.74k|  mrb_define_method(mrb, f, "inspect", false_to_s,  MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  335|  1.74k|}
mrb_type_convert:
  363|      5|{
  364|      5|  mrb_value v;
  365|      5|  const char *tname;
  366|       |
  367|      5|  if (mrb_type(val) == type) return val;
  ------------------
  |  Branch (367:7): [True: 0, False: 5]
  ------------------
  368|      5|  tname = type_name(type);
  369|      5|  v = convert_type(mrb, val, tname, method, TRUE);
  ------------------
  |  |   54|      5|#  define TRUE 1
  ------------------
  370|      5|  if (mrb_type(v) != type) {
  ------------------
  |  Branch (370:7): [True: 0, False: 5]
  ------------------
  371|      0|    if (type == MRB_TT_STRING) return mrb_any_to_s(mrb, val);
  ------------------
  |  Branch (371:9): [True: 0, False: 0]
  ------------------
  372|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%n", val, tname, method);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  373|      0|  }
  374|      5|  return v;
  375|      5|}
mrb_check_type:
  390|  48.8k|{
  391|  48.8k|  enum mrb_vtype xt = mrb_type(x);
  392|  48.8k|  const char *tname, *ename;
  393|       |
  394|  48.8k|  if (t == xt) return;
  ------------------
  |  Branch (394:7): [True: 48.8k, False: 0]
  ------------------
  395|       |
  396|      0|  tname = type_name(t);
  397|      0|  if (mrb_nil_p(x)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  398|      0|    ename = "nil";
  399|      0|  }
  400|      0|  else if (mrb_integer_p(x)) {
  ------------------
  |  |  171|      0|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  401|      0|    ename = "Integer";
  402|      0|  }
  403|      0|  else if (mrb_symbol_p(x)) {
  ------------------
  |  |  172|      0|#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
  |  |  ------------------
  |  |  |  |   76|      0|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  404|      0|    ename = "Symbol";
  405|      0|  }
  406|      0|  else if (mrb_immediate_p(x)) {
  ------------------
  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  ------------------
  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  407|      0|    ename = RSTRING_PTR(mrb_obj_as_string(mrb, x));
  ------------------
  |  |  100|      0|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  408|      0|  }
  409|      0|  else {
  410|      0|    ename = mrb_obj_classname(mrb, x);
  411|      0|  }
  412|      0|  if (tname) {
  ------------------
  |  Branch (412:7): [True: 0, False: 0]
  ------------------
  413|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  414|      0|               ename, tname);
  415|      0|  }
  416|      0|  mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%s given)", t, ename);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  417|      0|}
mrb_obj_is_kind_of:
  475|  40.8k|{
  476|  40.8k|  struct RClass *cl = mrb_class(mrb, obj);
  477|       |
  478|  40.8k|  switch (c->tt) {
  479|      0|    case MRB_TT_MODULE:
  ------------------
  |  Branch (479:5): [True: 0, False: 40.8k]
  ------------------
  480|  40.8k|    case MRB_TT_CLASS:
  ------------------
  |  Branch (480:5): [True: 40.8k, False: 0]
  ------------------
  481|  40.8k|    case MRB_TT_ICLASS:
  ------------------
  |  Branch (481:5): [True: 0, False: 40.8k]
  ------------------
  482|  40.8k|    case MRB_TT_SCLASS:
  ------------------
  |  Branch (482:5): [True: 0, False: 40.8k]
  ------------------
  483|  40.8k|      break;
  484|       |
  485|      0|    default:
  ------------------
  |  Branch (485:5): [True: 0, False: 40.8k]
  ------------------
  486|      0|      mrb_raise(mrb, E_TYPE_ERROR, "class or module required");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  487|  40.8k|  }
  488|       |
  489|  40.8k|  MRB_CLASS_ORIGIN(c);
  ------------------
  |  |   65|  40.8k|#define MRB_CLASS_ORIGIN(c) do {\
  |  |   66|  40.8k|  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
  |  |  ------------------
  |  |  |  |   63|  40.8k|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  |  |  ------------------
  |  |  |  Branch (66:7): [True: 0, False: 40.8k]
  |  |  ------------------
  |  |   67|      0|    (c) = (c)->super;\
  |  |   68|      0|    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
  |  |  ------------------
  |  |  |  |   64|      0|#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
  |  |  ------------------
  |  |  |  Branch (68:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|      (c) = (c)->super;\
  |  |   70|      0|    }\
  |  |   71|      0|  }\
  |  |   72|  40.8k|} while (0)
  |  |  ------------------
  |  |  |  Branch (72:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  490|   218k|  while (cl) {
  ------------------
  |  Branch (490:10): [True: 188k, False: 29.5k]
  ------------------
  491|   188k|    if (cl == c || cl->mt == c->mt)
  ------------------
  |  Branch (491:9): [True: 11.3k, False: 177k]
  |  Branch (491:20): [True: 0, False: 177k]
  ------------------
  492|  11.3k|      return TRUE;
  ------------------
  |  |   54|  11.3k|#  define TRUE 1
  ------------------
  493|   177k|    cl = cl->super;
  494|   177k|  }
  495|  29.5k|  return FALSE;
  ------------------
  |  |   51|  29.5k|#  define FALSE 0
  ------------------
  496|  40.8k|}
mrb_ensure_integer_type:
  511|  29.4k|{
  512|  29.4k|  if (!mrb_integer_p(val)) {
  ------------------
  |  |  171|  29.4k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|  58.9k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 26.1k, False: 3.30k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|  3.30k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  6.60k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  6.60k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 830, False: 2.47k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 2.47k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 2.44k, False: 29]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  513|    859|#ifndef MRB_NO_FLOAT
  514|    859|    if (mrb_float_p(val)) {
  ------------------
  |  |  179|    859|#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
  |  |  ------------------
  |  |  |  |   76|    859|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 806, False: 53]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  515|    806|      return mrb_float_to_integer(mrb, val);
  516|    806|    }
  517|     53|    else {
  518|     53|      switch (mrb_type(val)) {
  519|      0|#ifdef MRB_USE_BIGINT
  520|     29|      case MRB_TT_BIGINT:
  ------------------
  |  Branch (520:7): [True: 29, False: 24]
  ------------------
  521|     29|        return val;
  522|      0|#endif
  523|      0|#ifdef MRB_USE_RATIONAL
  524|      0|      case MRB_TT_RATIONAL:
  ------------------
  |  Branch (524:7): [True: 0, False: 53]
  ------------------
  525|      0|        return mrb_rational_to_i(mrb, val);
  526|      0|#endif
  527|      0|#ifdef MRB_USE_COMPLEX
  528|      0|      case MRB_TT_COMPLEX:
  ------------------
  |  Branch (528:7): [True: 0, False: 53]
  ------------------
  529|      0|        return mrb_complex_to_i(mrb, val);
  530|      0|#endif
  531|     24|      default:
  ------------------
  |  Branch (531:7): [True: 24, False: 29]
  ------------------
  532|     24|        break;
  533|     53|      }
  534|     53|    }
  535|     24|#endif
  536|     24|    mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Integer", val);
  ------------------
  |  | 1375|     24|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|     24|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     24|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  537|    859|  }
  538|  28.5k|  return val;
  539|  29.4k|}
mrb_ensure_int_type:
  543|  29.4k|{
  544|  29.4k|  val = mrb_ensure_integer_type(mrb, val);
  545|  29.4k|#ifdef MRB_USE_BIGINT
  546|  29.4k|  if (mrb_bigint_p(val)) {
  ------------------
  |  |  314|  29.4k|#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
  |  |  ------------------
  |  |  |  Branch (314:25): [True: 41, False: 29.4k]
  |  |  ------------------
  ------------------
  547|     41|    return mrb_int_value(mrb, mrb_bint_as_int(mrb, val));
  548|     41|  }
  549|  29.4k|#endif
  550|  29.4k|  return val;
  551|  29.4k|}
mrb_ensure_float_type:
  556|  9.87k|{
  557|  9.87k|  if (mrb_nil_p(val)) {
  ------------------
  |  |  174|  9.87k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 9.87k]
  |  |  ------------------
  ------------------
  558|      0|    mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  559|      0|  }
  560|  9.87k|  switch (mrb_type(val)) {
  561|  4.22k|    case MRB_TT_INTEGER:
  ------------------
  |  Branch (561:5): [True: 4.22k, False: 5.65k]
  ------------------
  562|  4.22k|      return mrb_float_value(mrb, (mrb_float)mrb_integer(val));
  ------------------
  |  |  166|  4.22k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  563|       |
  564|  3.60k|    case MRB_TT_FLOAT:
  ------------------
  |  Branch (564:5): [True: 3.60k, False: 6.27k]
  ------------------
  565|  3.60k|      return val;
  566|       |
  567|      0|#ifdef MRB_USE_RATIONAL
  568|      0|    case MRB_TT_RATIONAL:
  ------------------
  |  Branch (568:5): [True: 0, False: 9.87k]
  ------------------
  569|      0|      return mrb_rational_to_f(mrb, val);
  570|      0|#endif
  571|       |
  572|      0|#ifdef MRB_USE_COMPLEX
  573|      0|    case MRB_TT_COMPLEX:
  ------------------
  |  Branch (573:5): [True: 0, False: 9.87k]
  ------------------
  574|      0|      return mrb_complex_to_f(mrb, val);
  575|      0|#endif
  576|       |
  577|      0|#ifdef MRB_USE_BIGINT
  578|  2.01k|    case MRB_TT_BIGINT:
  ------------------
  |  Branch (578:5): [True: 2.01k, False: 7.86k]
  ------------------
  579|  2.01k|      return mrb_float_value(mrb, mrb_bint_as_float(mrb, val));
  580|      0|#endif
  581|       |
  582|     34|    default:
  ------------------
  |  Branch (582:5): [True: 34, False: 9.84k]
  ------------------
  583|     34|      mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Float", val);
  ------------------
  |  | 1375|     34|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|     34|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     34|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  584|       |      /* not reached */
  585|      0|      return val;
  586|  9.87k|  }
  587|  9.87k|}
mrb_ensure_string_type:
  592|  9.33k|{
  593|  9.33k|  if (!mrb_string_p(str)) {
  ------------------
  |  |  187|  9.33k|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|  9.33k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  18.6k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  18.6k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 9.33k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 9.33k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 9.33k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  594|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to String", str);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  595|      0|  }
  596|  9.33k|  return str;
  597|  9.33k|}
mrb_ensure_array_type:
  608|  11.3k|{
  609|  11.3k|  if (!mrb_array_p(ary)) {
  ------------------
  |  |  186|  11.3k|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|  11.3k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  22.6k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  22.6k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 11.3k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 11.3k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 11.3k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  610|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Array", ary);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  611|      0|  }
  612|  11.3k|  return ary;
  613|  11.3k|}
mrb_check_array_type:
  617|    673|{
  618|    673|  if (!mrb_array_p(ary)) return mrb_nil_value();
  ------------------
  |  |  186|    673|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|    673|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  1.34k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  1.34k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 673, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  619|      0|  return ary;
  620|    673|}
mrb_ensure_hash_type:
  624|  47.0k|{
  625|  47.0k|  if (!mrb_hash_p(hash)) {
  ------------------
  |  |  188|  47.0k|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|  47.0k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  94.1k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  94.1k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 47.0k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 47.0k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 47.0k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  626|      0|    mrb_raisef(mrb, E_TYPE_ERROR, "%Y cannot be converted to Hash", hash);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  627|      0|  }
  628|  47.0k|  return hash;
  629|  47.0k|}
mrb_inspect:
  640|     72|{
  641|     72|  mrb_value v = mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0);
  ------------------
  |  |   18|     72|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  642|     72|  if (!mrb_string_p(v)) {
  ------------------
  |  |  187|     72|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|     72|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|    144|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|    144|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 72]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 72]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 72, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  643|      0|    v = mrb_obj_as_string(mrb, obj);
  644|      0|  }
  645|     72|  return v;
  646|     72|}
object.c:false_xor:
  258|    566|{
  259|    566|  mrb_bool obj2;
  260|       |
  261|    566|  mrb_get_args(mrb, "b", &obj2);
  262|    566|  return mrb_bool_value(obj2);
  263|    566|}
object.c:mrb_true:
  101|  1.59k|{
  102|  1.59k|  return mrb_true_value();
  103|  1.59k|}
object.c:true_xor:
  169|    962|{
  170|    962|  mrb_bool obj2;
  171|       |
  172|    962|  mrb_get_args(mrb, "b", &obj2);
  173|    962|  return mrb_bool_value(!obj2);
  174|    962|}
object.c:true_to_s:
  186|     41|{
  187|     41|  mrb_value str = mrb_str_new_lit_frozen(mrb, "true");
  ------------------
  |  | 1215|     41|#define mrb_str_new_lit_frozen(mrb,lit) mrb_obj_freeze(mrb,mrb_str_new_lit(mrb,lit))
  |  |  ------------------
  |  |  |  | 1209|     41|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1075|     41|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  188|     41|  RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
  ------------------
  |  |   89|     41|# define RSTR_SET_ASCII_FLAG(s) (void)0
  ------------------
  189|     41|  return str;
  190|     41|}
object.c:false_to_s:
  295|     31|{
  296|     31|  mrb_value str = mrb_str_new_lit_frozen(mrb, "false");
  ------------------
  |  | 1215|     31|#define mrb_str_new_lit_frozen(mrb,lit) mrb_obj_freeze(mrb,mrb_str_new_lit(mrb,lit))
  |  |  ------------------
  |  |  |  | 1209|     31|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1075|     31|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  297|     31|  RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
  ------------------
  |  |   89|     31|# define RSTR_SET_ASCII_FLAG(s) (void)0
  ------------------
  298|     31|  return str;
  299|     31|}
object.c:type_name:
  339|      5|{
  340|      5|  switch (t) {
  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  ------------------
  |  |  135|      0|  f(MRB_TT_FALSE,       void,               "false") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  136|      0|  f(MRB_TT_TRUE,        void,               "true") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  137|      0|  f(MRB_TT_SYMBOL,      void,               "Symbol") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  138|      0|  f(MRB_TT_UNDEF,       void,               "undefined") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  139|      0|  f(MRB_TT_FREE,        void,               "free") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  140|      0|  f(MRB_TT_FLOAT,       struct RFloat,      "Float") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  141|      0|  f(MRB_TT_INTEGER,     struct RInteger,    "Integer") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  142|      0|  f(MRB_TT_CPTR,        struct RCptr,       "cptr") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|  f(MRB_TT_OBJECT,      struct RObject,     "Object") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  144|      0|  f(MRB_TT_CLASS,       struct RClass,      "Class") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  145|      0|  f(MRB_TT_MODULE,      struct RClass,      "Module") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|  f(MRB_TT_ICLASS,      struct RClass,      "iClass") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  147|      0|  f(MRB_TT_SCLASS,      struct RClass,      "SClass") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  148|      0|  f(MRB_TT_PROC,        struct RProc,       "Proc") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  149|      0|  f(MRB_TT_ARRAY,       struct RArray,      "Array") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  150|      0|  f(MRB_TT_HASH,        struct RHash,       "Hash") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  151|      5|  f(MRB_TT_STRING,      struct RString,     "String") \
  |  |  ------------------
  |  |  |  |  342|      5|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      5|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 5, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  152|      5|  f(MRB_TT_RANGE,       struct RRange,      "Range") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  153|      0|  f(MRB_TT_EXCEPTION,   struct RException,  "Exception") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  154|      0|  f(MRB_TT_ENV,         struct REnv,        "env") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  155|      0|  f(MRB_TT_CDATA,       struct RData,       "C data") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  156|      0|  f(MRB_TT_FIBER,       struct RFiber,      "Fiber") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  157|      0|  f(MRB_TT_STRUCT,      struct RArray,      "Struct") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  158|      0|  f(MRB_TT_ISTRUCT,     struct RIStruct,    "istruct") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  159|      0|  f(MRB_TT_BREAK,       struct RBreak,      "break") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  160|      0|  f(MRB_TT_COMPLEX,     struct RComplex,    "Complex") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  161|      0|  f(MRB_TT_RATIONAL,    struct RRational,   "Rational") \
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  162|      0|  f(MRB_TT_BIGINT,      struct RBigint,     "Integer")
  |  |  ------------------
  |  |  |  |  342|      0|    MRB_VTYPE_FOREACH(MRB_VTYPE_NAME)
  |  |  |  |  ------------------
  |  |  |  |  |  |  341|      0|#define MRB_VTYPE_NAME(tt, type, name) case tt: return name;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (341:40): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  343|      0|#undef MRB_VTYPE_NAME
  344|      0|    default: return NULL;
  ------------------
  |  Branch (344:5): [True: 0, False: 5]
  ------------------
  345|      5|  }
  346|      5|}
object.c:convert_type:
  350|      5|{
  351|      5|  if (!mrb_respond_to(mrb, val, method)) {
  ------------------
  |  Branch (351:7): [True: 0, False: 5]
  ------------------
  352|      0|    if (raise) {
  ------------------
  |  Branch (352:9): [True: 0, False: 0]
  ------------------
  353|      0|      if (tname) mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (353:11): [True: 0, False: 0]
  ------------------
  354|      0|      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y", val);
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  355|      0|    }
  356|      0|    return mrb_nil_value();
  357|      0|  }
  358|      5|  return mrb_funcall_argv(mrb, val, method, 0, 0);
  359|      5|}

mrb_pool_open:
   65|  6.93k|{
   66|  6.93k|  mrb_pool *pool = (mrb_pool*)mrb_malloc_simple(mrb, sizeof(mrb_pool));
   67|       |
   68|  6.93k|  if (pool) {
  ------------------
  |  Branch (68:7): [True: 6.93k, False: 0]
  ------------------
   69|  6.93k|    pool->mrb = mrb;
   70|  6.93k|    pool->pages = NULL;
   71|  6.93k|  }
   72|       |
   73|  6.93k|  return pool;
   74|  6.93k|}
mrb_pool_close:
   78|  6.93k|{
   79|  6.93k|  struct mrb_pool_page *page, *tmp;
   80|       |
   81|  6.93k|  if (!pool) return;
  ------------------
  |  Branch (81:7): [True: 0, False: 6.93k]
  ------------------
   82|  6.93k|  page = pool->pages;
   83|  24.9k|  while (page) {
  ------------------
  |  Branch (83:10): [True: 18.0k, False: 6.93k]
  ------------------
   84|  18.0k|    tmp = page;
   85|  18.0k|    page = page->next;
   86|  18.0k|    mrb_free(pool->mrb, tmp);
   87|  18.0k|  }
   88|  6.93k|  mrb_free(pool->mrb, pool);
   89|  6.93k|}
mrb_pool_alloc:
  109|  8.47M|{
  110|  8.47M|  struct mrb_pool_page *page;
  111|  8.47M|  size_t n;
  112|       |
  113|  8.47M|  if (!pool) return NULL;
  ------------------
  |  Branch (113:7): [True: 0, False: 8.47M]
  ------------------
  114|  8.47M|  len += ALIGN_PADDING(len);
  ------------------
  |  |   58|  8.47M|#  define ALIGN_PADDING(x) ((SIZE_MAX - (x) + 1) & (POOL_ALIGNMENT - 1))
  |  |  ------------------
  |  |  |  |   15|  8.47M|#define POOL_ALIGNMENT 8
  |  |  ------------------
  ------------------
  115|  8.47M|  page = pool->pages;
  116|  8.68M|  while (page) {
  ------------------
  |  Branch (116:10): [True: 8.66M, False: 18.0k]
  ------------------
  117|  8.66M|    if (page->offset + len <= page->len) {
  ------------------
  |  Branch (117:9): [True: 8.46M, False: 204k]
  ------------------
  118|  8.46M|      n = page->offset;
  119|  8.46M|      page->offset += len;
  120|  8.46M|      page->last = (char*)page->page+n;
  121|  8.46M|      return page->last;
  122|  8.46M|    }
  123|   204k|    page = page->next;
  124|   204k|  }
  125|  18.0k|  page = page_alloc(pool, len);
  126|  18.0k|  if (!page) return NULL;
  ------------------
  |  Branch (126:7): [True: 0, False: 18.0k]
  ------------------
  127|  18.0k|  page->offset = len;
  128|  18.0k|  page->next = pool->pages;
  129|  18.0k|  pool->pages = page;
  130|       |
  131|  18.0k|  page->last = (void*)page->page;
  132|  18.0k|  return page->last;
  133|  18.0k|}
pool.c:page_alloc:
   93|  18.0k|{
   94|  18.0k|  struct mrb_pool_page *page;
   95|       |
   96|  18.0k|  if (len < POOL_PAGE_SIZE)
  ------------------
  |  |   22|  18.0k|#define POOL_PAGE_SIZE 16000
  ------------------
  |  Branch (96:7): [True: 17.9k, False: 96]
  ------------------
   97|  17.9k|    len = POOL_PAGE_SIZE;
  ------------------
  |  |   22|  17.9k|#define POOL_PAGE_SIZE 16000
  ------------------
   98|  18.0k|  page = (struct mrb_pool_page*)mrb_malloc_simple(pool->mrb, sizeof(struct mrb_pool_page)+len);
   99|  18.0k|  if (page) {
  ------------------
  |  Branch (99:7): [True: 18.0k, False: 0]
  ------------------
  100|  18.0k|    page->offset = 0;
  101|  18.0k|    page->len = len;
  102|  18.0k|  }
  103|       |
  104|  18.0k|  return page;
  105|  18.0k|}

mrb_proc_new:
   46|   959k|{
   47|   959k|  struct RProc *p;
   48|   959k|  mrb_callinfo *ci = mrb->c->ci;
   49|       |
   50|   959k|  p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
  ------------------
  |  | 1200|   959k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
   51|   959k|  if (ci) {
  ------------------
  |  Branch (51:7): [True: 959k, False: 0]
  ------------------
   52|   959k|    struct RClass *tc = NULL;
   53|       |
   54|   959k|    if (ci->proc) {
  ------------------
  |  Branch (54:9): [True: 959k, False: 0]
  ------------------
   55|   959k|      tc = MRB_PROC_TARGET_CLASS(ci->proc);
  ------------------
  |  |   74|   959k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|   959k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   959k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 1.74k, False: 957k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   56|   959k|    }
   57|   959k|    if (tc == NULL) {
  ------------------
  |  Branch (57:9): [True: 118k, False: 840k]
  ------------------
   58|   118k|      tc = mrb_vm_ci_target_class(ci);
   59|   118k|    }
   60|   959k|    p->upper = ci->proc;
   61|   959k|    p->e.target_class = tc;
   62|   959k|  }
   63|   959k|  if (irep) {
  ------------------
  |  Branch (63:7): [True: 959k, False: 0]
  ------------------
   64|   959k|    mrb_irep_incref(mrb, (mrb_irep*)irep);
   65|   959k|  }
   66|   959k|  p->body.irep = irep;
   67|       |
   68|   959k|  return p;
   69|   959k|}
mrb_env_new:
   73|  68.0k|{
   74|  68.0k|  struct REnv *e;
   75|  68.0k|  mrb_int bidx = 1;
   76|  68.0k|  int n = ci->n;
   77|  68.0k|  int nk = ci->nk;
   78|       |
   79|  68.0k|  e = MRB_OBJ_ALLOC(mrb, MRB_TT_ENV, NULL);
  ------------------
  |  | 1200|  68.0k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
   80|  68.0k|  e->c = tc;
   81|  68.0k|  MRB_ENV_SET_LEN(e, nstacks);
  ------------------
  |  |   26|  68.0k|#define MRB_ENV_SET_LEN(e,len) ((e)->flags = (((e)->flags & ~0xff)|((unsigned int)(len) & 0xff)))
  ------------------
   82|  68.0k|  bidx += (n == 15) ? 1 : n;
  ------------------
  |  Branch (82:11): [True: 27.9k, False: 40.1k]
  ------------------
   83|  68.0k|  bidx += (nk == 15) ? 1 : (2*nk);
  ------------------
  |  Branch (83:11): [True: 0, False: 68.0k]
  ------------------
   84|  68.0k|  MRB_ENV_SET_BIDX(e, bidx);
  ------------------
  |  |   32|  68.0k|#define MRB_ENV_SET_BIDX(e,idx) ((e)->flags = (((e)->flags & ~(0xff<<8))|((unsigned int)(idx) & 0xff)<<8))
  ------------------
   85|  68.0k|  e->mid = ci->mid;
   86|  68.0k|  e->stack = stack;
   87|  68.0k|  e->cxt = c;
   88|       |
   89|  68.0k|  return e;
   90|  68.0k|}
mrb_closure_new:
  120|  24.4k|{
  121|  24.4k|  struct RProc *p = mrb_proc_new(mrb, irep);
  122|       |
  123|  24.4k|  closure_setup(mrb, p);
  124|  24.4k|  return p;
  125|  24.4k|}
mrb_proc_new_cfunc:
  129|  43.6k|{
  130|  43.6k|  struct RProc *p;
  131|       |
  132|  43.6k|  p = MRB_OBJ_ALLOC(mrb, MRB_TT_PROC, mrb->proc_class);
  ------------------
  |  | 1200|  43.6k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  ------------------
  133|  43.6k|  p->body.func = func;
  134|  43.6k|  p->flags |= MRB_PROC_CFUNC_FL;
  ------------------
  |  |   64|  43.6k|#define MRB_PROC_CFUNC_FL 128
  ------------------
  135|  43.6k|  p->upper = 0;
  136|  43.6k|  p->e.target_class = 0;
  137|       |
  138|  43.6k|  return p;
  139|  43.6k|}
mrb_proc_new_cfunc_with_env:
  143|  43.6k|{
  144|  43.6k|  struct RProc *p = mrb_proc_new_cfunc(mrb, func);
  145|  43.6k|  struct REnv *e;
  146|  43.6k|  int i;
  147|       |
  148|  43.6k|  p->e.env = e = mrb_env_new(mrb, mrb->c, mrb->c->ci, 0, NULL, NULL);
  149|  43.6k|  p->flags |= MRB_PROC_ENVSET;
  ------------------
  |  |   71|  43.6k|#define MRB_PROC_ENVSET 1024
  ------------------
  150|  43.6k|  mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
  151|  43.6k|  MRB_ENV_CLOSE(e);
  ------------------
  |  |   29|  43.6k|#define MRB_ENV_CLOSE(e) ((e)->flags |= MRB_ENV_CLOSED)
  |  |  ------------------
  |  |  |  |   28|  43.6k|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
  152|       |
  153|  43.6k|  e->stack = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * argc);
  154|  43.6k|  MRB_ENV_SET_LEN(e, argc);
  ------------------
  |  |   26|  43.6k|#define MRB_ENV_SET_LEN(e,len) ((e)->flags = (((e)->flags & ~0xff)|((unsigned int)(len) & 0xff)))
  ------------------
  155|       |
  156|  43.6k|  if (argv) {
  ------------------
  |  Branch (156:7): [True: 43.6k, False: 0]
  ------------------
  157|  87.2k|    for (i = 0; i < argc; i++) {
  ------------------
  |  Branch (157:17): [True: 43.6k, False: 43.6k]
  ------------------
  158|  43.6k|      e->stack[i] = argv[i];
  159|  43.6k|    }
  160|  43.6k|  }
  161|      0|  else {
  162|      0|    for (i = 0; i < argc; i++) {
  ------------------
  |  Branch (162:17): [True: 0, False: 0]
  ------------------
  163|      0|      SET_NIL_VALUE(e->stack[i]);
  ------------------
  |  |  210|      0|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
  164|      0|    }
  165|      0|  }
  166|  43.6k|  return p;
  167|  43.6k|}
mrb_init_proc:
  491|  1.74k|{
  492|  1.74k|  mrb_method_t m;
  493|       |
  494|  1.74k|  mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
                mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  495|  1.74k|  mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  496|  1.74k|  mrb_define_method(mrb, mrb->proc_class, "arity", proc_arity, MRB_ARGS_NONE()); /* 15.2.17.4.2 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  497|  1.74k|  mrb_define_method(mrb, mrb->proc_class, "==", proc_eql, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  498|  1.74k|  mrb_define_method(mrb, mrb->proc_class, "eql?", proc_eql, MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  499|  1.74k|  mrb_define_method(mrb, mrb->proc_class, "hash", proc_hash, MRB_ARGS_NONE()); /* 15.2.17.4.2 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  500|       |
  501|  1.74k|  MRB_METHOD_FROM_PROC(m, &call_proc);
  ------------------
  |  |  112|  1.74k|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
  502|  1.74k|  mrb_define_method_raw(mrb, mrb->proc_class, MRB_SYM(call), m);   /* 15.2.17.4.3 */
  ------------------
  |  |   18|  1.74k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  503|  1.74k|  mrb_define_method_raw(mrb, mrb->proc_class, MRB_OPSYM(aref), m); /* 15.2.17.4.1 */
  ------------------
  |  |   12|  1.74k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  ------------------
  504|       |
  505|  1.74k|  mrb_define_method(mrb, mrb->kernel_module,       "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
                mrb_define_method(mrb, mrb->kernel_module,       "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */
  ------------------
  |  |  909|  1.74k|#define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
  ------------------
  506|  1.74k|}
proc.c:closure_setup:
   94|  24.4k|{
   95|  24.4k|  mrb_callinfo *ci = mrb->c->ci;
   96|  24.4k|  const struct RProc *up = p->upper;
   97|  24.4k|  struct REnv *e = NULL;
   98|       |
   99|  24.4k|  if (ci && (e = mrb_vm_ci_env(ci)) != NULL) {
  ------------------
  |  Branch (99:7): [True: 24.4k, False: 0]
  |  Branch (99:13): [True: 0, False: 24.4k]
  ------------------
  100|       |    /* do nothing, because e is assigned already */
  101|      0|  }
  102|  24.4k|  else if (up) {
  ------------------
  |  Branch (102:12): [True: 24.4k, False: 0]
  ------------------
  103|  24.4k|    struct RClass *tc = ci->u.target_class;
  104|       |
  105|  24.4k|    e = mrb_env_new(mrb, mrb->c, ci, up->body.irep->nlocals, ci->stack, tc);
  106|  24.4k|    ci->u.env = e;
  107|  24.4k|    if (MRB_PROC_ENV_P(up) && MRB_PROC_ENV(up)->cxt == NULL) {
  ------------------
  |  |   72|  48.8k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|  24.4k|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 0, False: 24.4k]
  |  |  ------------------
  ------------------
                  if (MRB_PROC_ENV_P(up) && MRB_PROC_ENV(up)->cxt == NULL) {
  ------------------
  |  |   73|      0|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (107:31): [True: 0, False: 0]
  ------------------
  108|      0|      e->mid = MRB_PROC_ENV(up)->mid;
  ------------------
  |  |   73|      0|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  109|      0|    }
  110|  24.4k|  }
  111|  24.4k|  if (e) {
  ------------------
  |  Branch (111:7): [True: 24.4k, False: 0]
  ------------------
  112|  24.4k|    p->e.env = e;
  113|  24.4k|    p->flags |= MRB_PROC_ENVSET;
  ------------------
  |  |   71|  24.4k|#define MRB_PROC_ENVSET 1024
  ------------------
  114|  24.4k|    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)e);
  115|  24.4k|  }
  116|  24.4k|}

mrb_get_values_at:
  413|    276|{
  414|    276|  mrb_int i, j, beg, len;
  415|    276|  mrb_value result;
  416|    276|  result = mrb_ary_new(mrb);
  417|       |
  418|    550|  for (i = 0; i < argc; i++) {
  ------------------
  |  Branch (418:15): [True: 276, False: 274]
  ------------------
  419|    276|    if (mrb_integer_p(argv[i])) {
  ------------------
  |  |  171|    276|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|    552|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 219, False: 57]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|     57|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|    114|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|    114|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 1, False: 56]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 56]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 55, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  420|    274|      mrb_ary_push(mrb, result, func(mrb, obj, mrb_integer(argv[i])));
  ------------------
  |  |  166|    274|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
  421|    274|    }
  422|      2|    else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == MRB_RANGE_OK) {
  ------------------
  |  |   51|      2|#  define FALSE 0
  ------------------
  |  Branch (422:14): [True: 0, False: 2]
  ------------------
  423|      0|      mrb_int const end = olen < beg + len ? olen : beg + len;
  ------------------
  |  Branch (423:27): [True: 0, False: 0]
  ------------------
  424|      0|      for (j = beg; j < end; j++) {
  ------------------
  |  Branch (424:21): [True: 0, False: 0]
  ------------------
  425|      0|        mrb_ary_push(mrb, result, func(mrb, obj, j));
  426|      0|      }
  427|       |
  428|      0|      for (; j < beg + len; j++) {
  ------------------
  |  Branch (428:14): [True: 0, False: 0]
  ------------------
  429|      0|        mrb_ary_push(mrb, result, mrb_nil_value());
  430|      0|      }
  431|      0|    }
  432|      2|    else {
  433|      2|      mrb_raisef(mrb, E_TYPE_ERROR, "invalid values selector: %v", argv[i]);
  ------------------
  |  | 1375|      2|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      2|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      2|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  434|      2|    }
  435|    276|  }
  436|       |
  437|    274|  return result;
  438|    276|}
mrb_range_beg_len:
  470|  13.0k|{
  471|  13.0k|  mrb_int beg, end;
  472|  13.0k|  mrb_bool excl;
  473|  13.0k|  struct RRange *r;
  474|       |
  475|  13.0k|  if (!mrb_range_p(range)) return MRB_RANGE_TYPE_MISMATCH;
  ------------------
  |  |  198|  13.0k|#define mrb_range_p(o) WORDBOX_OBJ_TYPE_P(o, RANGE)
  |  |  ------------------
  |  |  |  |   78|  13.0k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  26.0k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  26.0k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 13.0k, False: 1]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  476|      0|  r = mrb_range_ptr(mrb, range);
  477|       |
  478|      0|  beg = mrb_nil_p(RANGE_BEG(r)) ? 0 : mrb_as_int(mrb, RANGE_BEG(r));
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                beg = mrb_nil_p(RANGE_BEG(r)) ? 0 : mrb_as_int(mrb, RANGE_BEG(r));
  ------------------
  |  | 1425|      0|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
  479|      0|  end = mrb_nil_p(RANGE_END(r)) ? -1 : mrb_as_int(mrb, RANGE_END(r));
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                end = mrb_nil_p(RANGE_END(r)) ? -1 : mrb_as_int(mrb, RANGE_END(r));
  ------------------
  |  | 1425|      0|#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val))
  |  |  ------------------
  |  |  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  |  |  ------------------
  ------------------
  480|      0|  excl = mrb_nil_p(RANGE_END(r)) ? 0 : RANGE_EXCL(r);
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                excl = mrb_nil_p(RANGE_END(r)) ? 0 : RANGE_EXCL(r);
  ------------------
  |  |   51|      0|#define RANGE_EXCL(p) ((p)->excl)
  ------------------
  481|       |
  482|      0|  if (beg < 0) {
  ------------------
  |  Branch (482:7): [True: 0, False: 0]
  ------------------
  483|      0|    beg += len;
  484|      0|    if (beg < 0) return MRB_RANGE_OUT;
  ------------------
  |  Branch (484:9): [True: 0, False: 0]
  ------------------
  485|      0|  }
  486|       |
  487|      0|  if (trunc) {
  ------------------
  |  Branch (487:7): [True: 0, False: 0]
  ------------------
  488|      0|    if (beg > len) return MRB_RANGE_OUT;
  ------------------
  |  Branch (488:9): [True: 0, False: 0]
  ------------------
  489|      0|    if (end > len) end = len;
  ------------------
  |  Branch (489:9): [True: 0, False: 0]
  ------------------
  490|      0|  }
  491|       |
  492|      0|  if (end < 0) end += len;
  ------------------
  |  Branch (492:7): [True: 0, False: 0]
  ------------------
  493|      0|  if (!excl && (!trunc || end < len)) end++;  /* include end point */
  ------------------
  |  Branch (493:7): [True: 0, False: 0]
  |  Branch (493:17): [True: 0, False: 0]
  |  Branch (493:27): [True: 0, False: 0]
  ------------------
  494|      0|  len = end - beg;
  495|      0|  if (len < 0) len = 0;
  ------------------
  |  Branch (495:7): [True: 0, False: 0]
  ------------------
  496|       |
  497|      0|  *begp = beg;
  498|      0|  *lenp = len;
  499|      0|  return MRB_RANGE_OK;
  500|      0|}
mrb_init_range:
  504|  1.74k|{
  505|  1.74k|  struct RClass *r;
  506|       |
  507|  1.74k|  r = mrb_define_class(mrb, "Range", mrb->object_class);                                /* 15.2.14 */
  508|  1.74k|  mrb->range_class = r;
  509|  1.74k|  MRB_SET_INSTANCE_TT(r, MRB_TT_RANGE);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  510|       |
  511|  1.74k|  mrb_define_method(mrb, r, "begin",           range_beg,             MRB_ARGS_NONE()); /* 15.2.14.4.3  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  512|  1.74k|  mrb_define_method(mrb, r, "end",             range_end,             MRB_ARGS_NONE()); /* 15.2.14.4.5  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  513|  1.74k|  mrb_define_method(mrb, r, "==",              range_eq,              MRB_ARGS_REQ(1)); /* 15.2.14.4.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  514|  1.74k|  mrb_define_method(mrb, r, "===",             range_include,         MRB_ARGS_REQ(1)); /* 15.2.14.4.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  515|  1.74k|  mrb_define_method(mrb, r, "exclude_end?",    range_excl,            MRB_ARGS_NONE()); /* 15.2.14.4.6  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  516|  1.74k|  mrb_define_method(mrb, r, "first",           range_beg,             MRB_ARGS_NONE()); /* 15.2.14.4.7  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  517|  1.74k|  mrb_define_method(mrb, r, "include?",        range_include,         MRB_ARGS_REQ(1)); /* 15.2.14.4.8  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  518|  1.74k|  mrb_define_method(mrb, r, "initialize",      range_initialize,      MRB_ARGS_ANY());  /* 15.2.14.4.9  */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
  519|  1.74k|  mrb_define_method(mrb, r, "last",            range_end,             MRB_ARGS_NONE()); /* 15.2.14.4.10 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  520|  1.74k|  mrb_define_method(mrb, r, "member?",         range_include,         MRB_ARGS_REQ(1)); /* 15.2.14.4.11 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  521|  1.74k|  mrb_define_method(mrb, r, "to_s",            range_to_s,            MRB_ARGS_NONE()); /* 15.2.14.4.12(x) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  522|  1.74k|  mrb_define_method(mrb, r, "inspect",         range_inspect,         MRB_ARGS_NONE()); /* 15.2.14.4.13(x) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  523|  1.74k|  mrb_define_method(mrb, r, "eql?",            range_eql,             MRB_ARGS_REQ(1)); /* 15.2.14.4.14(x) */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  524|  1.74k|  mrb_define_method(mrb, r, "initialize_copy", range_initialize_copy, MRB_ARGS_REQ(1)); /* 15.2.14.4.15(x) */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  525|  1.74k|  mrb_define_method(mrb, r, "__num_to_a",      range_num_to_a,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  526|  1.74k|}

mrb_open_core:
   40|  1.74k|{
   41|  1.74k|  static const mrb_state mrb_state_zero = { 0 };
   42|  1.74k|  mrb_state *mrb;
   43|       |
   44|  1.74k|  if (f == NULL) f = mrb_default_allocf;
  ------------------
  |  Branch (44:7): [True: 0, False: 1.74k]
  ------------------
   45|  1.74k|  mrb = (mrb_state*)(f)(NULL, NULL, sizeof(mrb_state), ud);
   46|  1.74k|  if (mrb == NULL) return NULL;
  ------------------
  |  Branch (46:7): [True: 0, False: 1.74k]
  ------------------
   47|       |
   48|  1.74k|  *mrb = mrb_state_zero;
   49|  1.74k|  mrb->allocf_ud = ud;
   50|  1.74k|  mrb->allocf = f;
   51|  1.74k|  mrb->atexit_stack_len = 0;
   52|       |
   53|  1.74k|  if (mrb_core_init_protect(mrb, init_gc_and_core, NULL)) {
  ------------------
  |  Branch (53:7): [True: 0, False: 1.74k]
  ------------------
   54|      0|    mrb_close(mrb);
   55|      0|    return NULL;
   56|      0|  }
   57|       |
   58|  1.74k|  return mrb;
   59|  1.74k|}
mrb_default_allocf:
   63|  3.63M|{
   64|  3.63M|  if (size == 0) {
  ------------------
  |  Branch (64:7): [True: 1.84M, False: 1.79M]
  ------------------
   65|  1.84M|    free(p);
   66|  1.84M|    return NULL;
   67|  1.84M|  }
   68|  1.79M|  else {
   69|  1.79M|    return realloc(p, size);
   70|  1.79M|  }
   71|  3.63M|}
mrb_open:
   75|  1.74k|{
   76|  1.74k|  mrb_state *mrb = mrb_open_allocf(mrb_default_allocf, NULL);
   77|       |
   78|  1.74k|  return mrb;
   79|  1.74k|}
mrb_open_allocf:
   91|  1.74k|{
   92|  1.74k|  mrb_state *mrb = mrb_open_core(f, ud);
   93|       |
   94|  1.74k|  if (mrb == NULL) {
  ------------------
  |  Branch (94:7): [True: 0, False: 1.74k]
  ------------------
   95|      0|    return NULL;
   96|      0|  }
   97|       |
   98|  1.74k|#ifndef MRB_NO_GEMS
   99|  1.74k|  if (mrb_core_init_protect(mrb, init_mrbgems, NULL)) {
  ------------------
  |  Branch (99:7): [True: 0, False: 1.74k]
  ------------------
  100|      0|    mrb_close(mrb);
  101|      0|    return NULL;
  102|      0|  }
  103|  1.74k|  mrb_gc_arena_restore(mrb, 0);
  ------------------
  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  104|  1.74k|#endif
  105|  1.74k|  return mrb;
  106|  1.74k|}
mrb_irep_incref:
  112|   959k|{
  113|   959k|  if (irep->flags & MRB_IREP_NO_FREE) return;
  ------------------
  |  |   82|   959k|#define MRB_IREP_NO_FREE 2
  ------------------
  |  Branch (113:7): [True: 956k, False: 3.08k]
  ------------------
  114|  3.08k|  if (irep->refcnt == UINT16_MAX) {
  ------------------
  |  Branch (114:7): [True: 0, False: 3.08k]
  ------------------
  115|      0|    mrb_garbage_collect(mrb);
  116|      0|    if (irep->refcnt == UINT16_MAX) {
  ------------------
  |  Branch (116:9): [True: 0, False: 0]
  ------------------
  117|      0|      mrb_raise(mrb, E_RUNTIME_ERROR, "too many irep references");
  ------------------
  |  | 1374|      0|#define E_RUNTIME_ERROR      mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError))
  |  |  ------------------
  |  |  |  | 1371|      0|#define MRB_ERROR_SYM(sym) mrb_intern_lit(mrb, #sym)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1164|      0|#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1075|      0|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  118|      0|    }
  119|      0|  }
  120|  3.08k|  irep->refcnt++;
  121|  3.08k|}
mrb_irep_decref:
  125|   962k|{
  126|   962k|  if (irep->flags & MRB_IREP_NO_FREE) return;
  ------------------
  |  |   82|   962k|#define MRB_IREP_NO_FREE 2
  ------------------
  |  Branch (126:7): [True: 956k, False: 6.54k]
  ------------------
  127|  6.54k|  irep->refcnt--;
  128|  6.54k|  if (irep->refcnt == 0) {
  ------------------
  |  Branch (128:7): [True: 3.46k, False: 3.08k]
  ------------------
  129|  3.46k|    mrb_irep_free(mrb, irep);
  130|  3.46k|  }
  131|  6.54k|}
mrb_irep_cutref:
  135|   935k|{
  136|   935k|  mrb_irep **reps;
  137|   935k|  int i;
  138|       |
  139|   935k|  if (irep->flags & MRB_IREP_NO_FREE) return;
  ------------------
  |  |   82|   935k|#define MRB_IREP_NO_FREE 2
  ------------------
  |  Branch (139:7): [True: 932k, False: 3.08k]
  ------------------
  140|  3.08k|  reps = (mrb_irep**)irep->reps;
  141|  3.08k|  if (!reps) return;
  ------------------
  |  Branch (141:7): [True: 1.54k, False: 1.54k]
  ------------------
  142|  3.08k|  for (i=0; i<irep->rlen; i++) {
  ------------------
  |  Branch (142:13): [True: 1.54k, False: 1.54k]
  ------------------
  143|  1.54k|    mrb_irep *tmp = reps[i];
  144|  1.54k|    reps[i] = NULL;
  145|  1.54k|    if (tmp) mrb_irep_decref(mrb, tmp);
  ------------------
  |  Branch (145:9): [True: 1.54k, False: 0]
  ------------------
  146|  1.54k|  }
  147|  1.54k|}
mrb_irep_free:
  151|  3.46k|{
  152|  3.46k|  int i;
  153|       |
  154|  3.46k|  if (irep->flags & MRB_IREP_NO_FREE) return;
  ------------------
  |  |   82|  3.46k|#define MRB_IREP_NO_FREE 2
  ------------------
  |  Branch (154:7): [True: 0, False: 3.46k]
  ------------------
  155|  3.46k|  if (!(irep->flags & MRB_ISEQ_NO_FREE))
  ------------------
  |  |   81|  3.46k|#define MRB_ISEQ_NO_FREE 1
  ------------------
  |  Branch (155:7): [True: 3.46k, False: 0]
  ------------------
  156|  3.46k|    mrb_free(mrb, (void*)irep->iseq);
  157|  3.46k|  if (irep->pool) {
  ------------------
  |  Branch (157:7): [True: 558, False: 2.90k]
  ------------------
  158|  18.3k|    for (i=0; i<irep->plen; i++) {
  ------------------
  |  Branch (158:15): [True: 17.8k, False: 558]
  ------------------
  159|  17.8k|      if ((irep->pool[i].tt & 3) == IREP_TT_STR ||
  ------------------
  |  Branch (159:11): [True: 17.3k, False: 445]
  ------------------
  160|  17.8k|          irep->pool[i].tt == IREP_TT_BIGINT) {
  ------------------
  |  Branch (160:11): [True: 0, False: 445]
  ------------------
  161|  17.3k|        mrb_free(mrb, (void*)irep->pool[i].u.str);
  162|  17.3k|      }
  163|  17.8k|    }
  164|    558|    mrb_free(mrb, (void*)irep->pool);
  165|    558|  }
  166|  3.46k|  mrb_free(mrb, (void*)irep->syms);
  167|  3.46k|  if (irep->reps) {
  ------------------
  |  Branch (167:7): [True: 1.54k, False: 1.92k]
  ------------------
  168|  3.08k|    for (i=0; i<irep->rlen; i++) {
  ------------------
  |  Branch (168:15): [True: 1.54k, False: 1.54k]
  ------------------
  169|  1.54k|      if (irep->reps[i])
  ------------------
  |  Branch (169:11): [True: 0, False: 1.54k]
  ------------------
  170|      0|        mrb_irep_decref(mrb, (mrb_irep*)irep->reps[i]);
  171|  1.54k|    }
  172|  1.54k|    mrb_free(mrb, (void*)irep->reps);
  173|  1.54k|  }
  174|  3.46k|  mrb_free(mrb, (void*)irep->lv);
  175|  3.46k|  mrb_debug_info_free(mrb, irep->debug_info);
  176|  3.46k|  mrb_free(mrb, irep);
  177|  3.46k|}
mrb_free_context:
  181|  1.74k|{
  182|  1.74k|  if (!c) return;
  ------------------
  |  Branch (182:7): [True: 0, False: 1.74k]
  ------------------
  183|  1.74k|  mrb_free(mrb, c->stbase);
  184|  1.74k|  mrb_free(mrb, c->cibase);
  185|  1.74k|  mrb_free(mrb, c);
  186|  1.74k|}
mrb_close:
  192|  1.74k|{
  193|  1.74k|  if (!mrb) return;
  ------------------
  |  Branch (193:7): [True: 0, False: 1.74k]
  ------------------
  194|  1.74k|  mrb_protect_atexit(mrb);
  195|       |
  196|       |  /* free */
  197|  1.74k|  mrb_gc_destroy(mrb, &mrb->gc);
  198|  1.74k|  mrb_free_context(mrb, mrb->root_c);
  199|  1.74k|  mrb_gc_free_gv(mrb);
  200|  1.74k|  mrb_free_symtbl(mrb);
  201|  1.74k|  mrb_free(mrb, mrb);
  202|  1.74k|}
mrb_add_irep:
  206|  3.46k|{
  207|  3.46k|  static const mrb_irep mrb_irep_zero = { 0 };
  208|  3.46k|  mrb_irep *irep;
  209|       |
  210|  3.46k|  irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
  211|  3.46k|  *irep = mrb_irep_zero;
  212|  3.46k|  irep->refcnt = 1;
  213|       |
  214|  3.46k|  return irep;
  215|  3.46k|}
mrb_top_self:
  219|  46.9k|{
  220|  46.9k|  return mrb_obj_value(mrb->top_self);
  221|  46.9k|}
mrb_state_atexit:
  225|  1.74k|{
  226|       |#ifdef MRB_FIXED_STATE_ATEXIT_STACK
  227|       |  if (mrb->atexit_stack_len + 1 > MRB_FIXED_STATE_ATEXIT_STACK_SIZE) {
  228|       |    mrb_raise(mrb, E_RUNTIME_ERROR, "exceeded fixed state atexit stack limit");
  229|       |  }
  230|       |#else
  231|  1.74k|  size_t stack_size;
  232|       |
  233|  1.74k|  stack_size = sizeof(mrb_atexit_func) * (mrb->atexit_stack_len + 1);
  234|  1.74k|  if (mrb->atexit_stack_len == 0) {
  ------------------
  |  Branch (234:7): [True: 1.74k, False: 0]
  ------------------
  235|  1.74k|    mrb->atexit_stack = (mrb_atexit_func*)mrb_malloc(mrb, stack_size);
  236|  1.74k|  }
  237|      0|  else {
  238|      0|    mrb->atexit_stack = (mrb_atexit_func*)mrb_realloc(mrb, mrb->atexit_stack, stack_size);
  239|      0|  }
  240|  1.74k|#endif
  241|       |
  242|  1.74k|  mrb->atexit_stack[mrb->atexit_stack_len++] = f;
  243|  1.74k|}
state.c:init_gc_and_core:
   27|  1.74k|{
   28|  1.74k|  static const struct mrb_context mrb_context_zero = { 0 };
   29|       |
   30|  1.74k|  mrb_gc_init(mrb, &mrb->gc);
   31|  1.74k|  mrb->c = (struct mrb_context*)mrb_malloc(mrb, sizeof(struct mrb_context));
   32|  1.74k|  *mrb->c = mrb_context_zero;
   33|  1.74k|  mrb->root_c = mrb->c;
   34|       |
   35|  1.74k|  mrb_init_core(mrb);
   36|  1.74k|}
state.c:init_mrbgems:
   84|  1.74k|{
   85|  1.74k|  mrb_init_mrbgems(mrb);
   86|  1.74k|}

mrb_str_new_capa:
  152|    307|{
  153|    307|  struct RString *s = mrb_obj_alloc_string(mrb);
  ------------------
  |  |   29|    307|#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class)
  |  |  ------------------
  |  |  |  | 1200|    307|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  |  |  ------------------
  ------------------
  154|       |
  155|    307|  if (RSTR_EMBEDDABLE_P(capa)) {
  ------------------
  |  |   63|    307|#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
  |  |  ------------------
  |  |  |  |   20|    307|  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
  |  |  ------------------
  |  |  |  Branch (63:32): [True: 0, False: 307]
  |  |  ------------------
  ------------------
  156|      0|    s = str_init_embed(s, NULL, 0);
  157|      0|  }
  158|    307|  else {
  159|    307|    s = str_init_normal_capa(mrb, s, NULL, 0, capa);
  160|    307|  }
  161|    307|  return mrb_obj_value(s);
  162|    307|}
mrb_str_new:
  181|   246k|{
  182|   246k|  return mrb_obj_value(str_new(mrb, p, len));
  183|   246k|}
mrb_str_new_cstr:
  187|  5.50k|{
  188|  5.50k|  struct RString *s;
  189|  5.50k|  mrb_int len;
  190|       |
  191|  5.50k|  if (p) {
  ------------------
  |  Branch (191:7): [True: 5.50k, False: 0]
  ------------------
  192|  5.50k|    len = strlen(p);
  193|  5.50k|  }
  194|      0|  else {
  195|      0|    len = 0;
  196|      0|  }
  197|       |
  198|  5.50k|  s = str_new(mrb, p, len);
  199|       |
  200|  5.50k|  return mrb_obj_value(s);
  201|  5.50k|}
mrb_str_new_static:
  205|  30.1k|{
  206|  30.1k|  struct RString *s = str_new_static(mrb, p, len);
  207|  30.1k|  return mrb_obj_value(s);
  208|  30.1k|}
mrb_gc_free_str:
  252|   403k|{
  253|   403k|  if (RSTR_EMBED_P(str))
  ------------------
  |  |   44|   403k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  ------------------
  |  |  |  |  110|   403k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  ------------------
  |  |  |  Branch (44:25): [True: 395k, False: 7.90k]
  |  |  ------------------
  ------------------
  254|   395k|    /* no code */;
  255|  7.90k|  else if (RSTR_SHARED_P(str))
  ------------------
  |  |   69|  7.90k|#define RSTR_SHARED_P(s) ((s)->flags & MRB_STR_SHARED)
  |  |  ------------------
  |  |  |  |  107|  7.90k|#define MRB_STR_SHARED    1
  |  |  ------------------
  |  |  |  Branch (69:26): [True: 4.26k, False: 3.64k]
  |  |  ------------------
  ------------------
  256|  4.26k|    str_decref(mrb, str->as.heap.aux.shared);
  257|  3.64k|  else if (!RSTR_NOFREE_P(str) && !RSTR_FSHARED_P(str))
  ------------------
  |  |   77|  7.28k|#define RSTR_NOFREE_P(s) ((s)->flags & MRB_STR_NOFREE)
  |  |  ------------------
  |  |  |  |  109|  3.64k|#define MRB_STR_NOFREE    4
  |  |  ------------------
  ------------------
                else if (!RSTR_NOFREE_P(str) && !RSTR_FSHARED_P(str))
  ------------------
  |  |   73|  1.89k|#define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
  |  |  ------------------
  |  |  |  |  108|  1.89k|#define MRB_STR_FSHARED   2
  |  |  ------------------
  ------------------
  |  Branch (257:12): [True: 1.89k, False: 1.74k]
  |  Branch (257:35): [True: 1.89k, False: 0]
  ------------------
  258|  1.89k|    mrb_free(mrb, str->as.heap.ptr);
  259|   403k|}
mrb_str_modify_keep_ascii:
  755|  32.5k|{
  756|  32.5k|  mrb_check_frozen(mrb, s);
  757|  32.5k|  str_modify_keep_ascii(mrb, s);
  758|  32.5k|}
mrb_str_modify:
  762|  32.5k|{
  763|  32.5k|  mrb_str_modify_keep_ascii(mrb, s);
  764|  32.5k|  RSTR_UNSET_ASCII_FLAG(s);
  ------------------
  |  |   90|  32.5k|# define RSTR_UNSET_ASCII_FLAG(s) (void)0
  ------------------
  765|  32.5k|}
mrb_str_concat:
  800|    105|{
  801|    105|  other = mrb_obj_as_string(mrb, other);
  802|    105|  mrb_str_cat_str(mrb, self, other);
  803|    105|}
mrb_str_equal:
  993|   113k|{
  994|   113k|  if (!mrb_string_p(str2)) return FALSE;
  ------------------
  |  |  187|   113k|#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
  |  |  ------------------
  |  |  |  |   78|   113k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|   227k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|   227k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 113k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 113k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 113k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (!mrb_string_p(str2)) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  995|   113k|  return str_eql(mrb, str1, str2);
  996|   113k|}
mrb_str_dup:
 1020|   120k|{
 1021|   120k|  struct RString *s = mrb_str_ptr(str);
  ------------------
  |  |   98|   120k|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|   120k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1022|   120k|  struct RString *dup = str_new(mrb, 0, 0);
 1023|       |
 1024|   120k|  return str_replace(mrb, dup, s);
 1025|   120k|}
mrb_byte_hash_step:
 1666|   367k|{
 1667|   367k|  const uint8_t *send = s + len;
 1668|       |
 1669|       |  /*
 1670|       |   * FNV-1 hash each octet in the buffer
 1671|       |   */
 1672|  2.16M|  while (s < send) {
  ------------------
  |  Branch (1672:10): [True: 1.79M, False: 367k]
  ------------------
 1673|       |    /* multiply by the 32 bit FNV magic prime mod 2^32 */
 1674|       |#if defined(NO_FNV_GCC_OPTIMIZATION)
 1675|       |    hval *= FNV_32_PRIME;
 1676|       |#else
 1677|  1.79M|    hval += (hval<<1) + (hval<<4) + (hval<<7) + (hval<<8) + (hval<<24);
 1678|  1.79M|#endif
 1679|       |
 1680|       |    /* xor the bottom with the current octet */
 1681|  1.79M|    hval ^= (uint32_t)*s++;
 1682|  1.79M|  }
 1683|       |
 1684|       |  /* return our new hash value */
 1685|   367k|  return hval;
 1686|   367k|}
mrb_byte_hash:
 1690|   367k|{
 1691|   367k|  return mrb_byte_hash_step(s, len, FNV1_32_INIT);
  ------------------
  |  | 1662|   367k|#define FNV1_32_INIT ((uint32_t)0x811c9dc5)
  ------------------
 1692|   367k|}
mrb_str_hash:
 1696|   125k|{
 1697|   125k|  struct RString *s = mrb_str_ptr(str);
  ------------------
  |  |   98|   125k|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|   125k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1698|   125k|  return mrb_byte_hash((uint8_t*)RSTR_PTR(s), RSTR_LEN(s));
  ------------------
  |  |   65|   125k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|   125k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|   125k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|   124k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 124k, False: 1.52k]
  |  |  ------------------
  ------------------
                return mrb_byte_hash((uint8_t*)RSTR_PTR(s), RSTR_LEN(s));
  ------------------
  |  |   66|   125k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|   125k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|   125k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|   124k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|   124k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|   124k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|   124k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|   124k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 124k, False: 1.52k]
  |  |  ------------------
  ------------------
 1699|   125k|}
mrb_obj_as_string:
 1883|    432|{
 1884|    432|  switch (mrb_type(obj)) {
 1885|     42|  case MRB_TT_STRING:
  ------------------
  |  Branch (1885:3): [True: 42, False: 390]
  ------------------
 1886|     42|    return obj;
 1887|    126|  case MRB_TT_SYMBOL:
  ------------------
  |  Branch (1887:3): [True: 126, False: 306]
  ------------------
 1888|    126|    return mrb_sym_str(mrb, mrb_symbol(obj));
  ------------------
  |  |  167|    126|#define mrb_symbol(o)  (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT)
  |  |  ------------------
  |  |  |  |   63|    126|#define WORDBOX_SYMBOL_SHIFT    32
  |  |  ------------------
  ------------------
 1889|    167|  case MRB_TT_INTEGER:
  ------------------
  |  Branch (1889:3): [True: 167, False: 265]
  ------------------
 1890|    167|    return mrb_integer_to_str(mrb, obj, 10);
 1891|      0|  case MRB_TT_SCLASS:
  ------------------
  |  Branch (1891:3): [True: 0, False: 432]
  ------------------
 1892|     92|  case MRB_TT_CLASS:
  ------------------
  |  Branch (1892:3): [True: 92, False: 340]
  ------------------
 1893|     92|  case MRB_TT_MODULE:
  ------------------
  |  Branch (1893:3): [True: 0, False: 432]
  ------------------
 1894|     92|    return mrb_mod_to_s(mrb, obj);
 1895|      5|  default:
  ------------------
  |  Branch (1895:3): [True: 5, False: 427]
  ------------------
 1896|      5|    return mrb_type_convert(mrb, obj, MRB_TT_STRING, MRB_SYM(to_s));
  ------------------
  |  |   18|      5|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
 1897|    432|  }
 1898|    432|}
mrb_string_value_cstr:
 2425|  5.23k|{
 2426|  5.23k|  struct RString *ps;
 2427|  5.23k|  const char *p;
 2428|  5.23k|  mrb_int len;
 2429|       |
 2430|  5.23k|  mrb_ensure_string_type(mrb, *ptr);
 2431|  5.23k|  ps = mrb_str_ptr(*ptr);
  ------------------
  |  |   98|  5.23k|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|  5.23k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2432|  5.23k|  check_null_byte(mrb, ps);
 2433|  5.23k|  p = RSTR_PTR(ps);
  ------------------
  |  |   65|  5.23k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|  5.23k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  5.23k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|  5.23k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 5.23k, False: 0]
  |  |  ------------------
  ------------------
 2434|  5.23k|  len = RSTR_LEN(ps);
  ------------------
  |  |   66|  5.23k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|  5.23k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  5.23k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|  5.23k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  5.23k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  5.23k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  5.23k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  5.23k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 5.23k, False: 0]
  |  |  ------------------
  ------------------
 2435|  5.23k|  if (p[len] == '\0') {
  ------------------
  |  Branch (2435:7): [True: 5.23k, False: 0]
  ------------------
 2436|  5.23k|    return p;
 2437|  5.23k|  }
 2438|       |
 2439|       |  /*
 2440|       |   * Even after str_modify_keep_ascii(), NULL termination is not ensured if
 2441|       |   * RSTR_SET_LEN() is used explicitly (e.g. String#delete_suffix!).
 2442|       |   */
 2443|      0|  str_modify_keep_ascii(mrb, ps);
 2444|      0|  RSTR_PTR(ps)[len] = '\0';
  ------------------
  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2445|      0|  return RSTR_PTR(ps);
  ------------------
  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2446|  5.23k|}
mrb_string_cstr:
 2450|  5.23k|{
 2451|  5.23k|  return mrb_string_value_cstr(mrb, &str);
 2452|  5.23k|}
mrb_str_cat:
 2697|  32.6k|{
 2698|  32.6k|  struct RString *s = mrb_str_ptr(str);
  ------------------
  |  |   98|  32.6k|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|  32.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2699|  32.6k|  mrb_int capa;
 2700|  32.6k|  mrb_int total;
 2701|  32.6k|  ptrdiff_t off = -1;
 2702|       |
 2703|  32.6k|  if (len == 0) return str;
  ------------------
  |  Branch (2703:7): [True: 66, False: 32.5k]
  ------------------
 2704|  32.5k|  mrb_str_modify(mrb, s);
 2705|  32.5k|  if (ptr >= RSTR_PTR(s) && ptr <= RSTR_PTR(s) + (size_t)RSTR_LEN(s)) {
  ------------------
  |  |   65|  65.1k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|  31.4k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 31.4k, False: 1.11k]
  |  |  ------------------
  ------------------
                if (ptr >= RSTR_PTR(s) && ptr <= RSTR_PTR(s) + (size_t)RSTR_LEN(s)) {
  ------------------
  |  |   65|    406|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|    406|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|    406|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|      2|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 2, False: 404]
  |  |  ------------------
  ------------------
                if (ptr >= RSTR_PTR(s) && ptr <= RSTR_PTR(s) + (size_t)RSTR_LEN(s)) {
  ------------------
  |  |   66|    406|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|    406|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|    406|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|      2|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|      2|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|      2|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      2|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|      2|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 2, False: 404]
  |  |  ------------------
  ------------------
  |  Branch (2705:7): [True: 406, False: 32.1k]
  |  Branch (2705:29): [True: 0, False: 406]
  ------------------
 2706|      0|      off = ptr - RSTR_PTR(s);
  ------------------
  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2707|      0|  }
 2708|       |
 2709|  32.5k|  capa = RSTR_CAPA(s);
  ------------------
  |  |   67|  32.5k|#define RSTR_CAPA(s) (RSTR_EMBED_P(s) ? RSTRING_EMBED_LEN_MAX : (s)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:25): [True: 31.4k, False: 1.11k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_CAPA(s) (RSTR_EMBED_P(s) ? RSTRING_EMBED_LEN_MAX : (s)->as.heap.aux.capa)
  |  |  ------------------
  |  |  |  |   20|  31.4k|  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
  |  |  ------------------
  ------------------
 2710|  32.5k|  if (mrb_int_add_overflow(RSTR_LEN(s), len, &total)) {
  ------------------
  |  |   66|  32.5k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|  31.4k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  31.4k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  31.4k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  31.4k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  31.4k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 31.4k, False: 1.11k]
  |  |  ------------------
  ------------------
  |  Branch (2710:7): [True: 0, False: 32.5k]
  ------------------
 2711|      0|  size_error:
 2712|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2713|      0|  }
 2714|  32.5k|  if (capa <= total) {
  ------------------
  |  Branch (2714:7): [True: 21, False: 32.5k]
  ------------------
 2715|     21|    if (capa == 0) capa = 1;
  ------------------
  |  Branch (2715:9): [True: 0, False: 21]
  ------------------
 2716|     42|    while (capa <= total) {
  ------------------
  |  Branch (2716:12): [True: 21, False: 21]
  ------------------
 2717|     21|      if (mrb_int_mul_overflow(capa, 2, &capa)) goto size_error;
  ------------------
  |  Branch (2717:11): [True: 0, False: 21]
  ------------------
 2718|     21|    }
 2719|     21|    resize_capa(mrb, s, capa);
 2720|     21|  }
 2721|  32.5k|  if (off != -1) {
  ------------------
  |  Branch (2721:7): [True: 0, False: 32.5k]
  ------------------
 2722|      0|      ptr = RSTR_PTR(s) + off;
  ------------------
  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2723|      0|  }
 2724|  32.5k|  memcpy(RSTR_PTR(s) + RSTR_LEN(s), ptr, len);
  ------------------
  |  |   65|  32.5k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|  31.4k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 31.4k, False: 1.13k]
  |  |  ------------------
  ------------------
                memcpy(RSTR_PTR(s) + RSTR_LEN(s), ptr, len);
  ------------------
  |  |   66|  32.5k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|  31.4k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  31.4k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  31.4k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  31.4k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  31.4k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 31.4k, False: 1.13k]
  |  |  ------------------
  ------------------
 2725|  32.5k|  RSTR_SET_LEN(s, total);
  ------------------
  |  |   52|  32.5k|#define RSTR_SET_LEN(s, n) do {\
  |  |   53|  32.5k|  if (RSTR_EMBED_P(s)) {\
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:25): [True: 31.4k, False: 1.13k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|  31.4k|    RSTR_SET_EMBED_LEN((s),(n));\
  |  |  ------------------
  |  |  |  |   47|  31.4k|#define RSTR_SET_EMBED_LEN(s, n) do {\
  |  |  |  |   48|  31.4k|  size_t tmp_n = (n);\
  |  |  |  |   49|  31.4k|  (s)->flags &= ~MRB_STR_EMBED_LEN_MASK;\
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  31.4k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  31.4k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  31.4k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   50|  31.4k|  (s)->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  31.4k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  |  |   51|  31.4k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|  31.4k|  }\
  |  |   56|  32.5k|  else {\
  |  |   57|  1.13k|    (s)->as.heap.len = (mrb_ssize)(n);\
  |  |   58|  1.13k|  }\
  |  |   59|  32.5k|} while (0)
  |  |  ------------------
  |  |  |  Branch (59:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2726|  32.5k|  RSTR_PTR(s)[total] = '\0';   /* sentinel */
  ------------------
  |  |   65|  32.5k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|  32.5k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  32.5k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|  31.4k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 31.4k, False: 1.13k]
  |  |  ------------------
  ------------------
 2727|  32.5k|  return str;
 2728|  32.5k|}
mrb_str_cat_str:
 2738|    105|{
 2739|    105|  if (mrb_str_ptr(str) == mrb_str_ptr(str2)) {
  ------------------
  |  |   98|    105|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|    105|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
                if (mrb_str_ptr(str) == mrb_str_ptr(str2)) {
  ------------------
  |  |   98|    105|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|    105|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  |  Branch (2739:7): [True: 0, False: 105]
  ------------------
 2740|      0|    mrb_str_modify(mrb, mrb_str_ptr(str));
  ------------------
  |  |   98|      0|#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2741|      0|  }
 2742|    105|  return mrb_str_cat(mrb, str, RSTRING_PTR(str2), RSTRING_LEN(str2));
  ------------------
  |  |  100|    105|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|    105|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|    105|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|    105|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|    105|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 105, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                return mrb_str_cat(mrb, str, RSTRING_PTR(str2), RSTRING_LEN(str2));
  ------------------
  |  |  102|    105|#define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
  |  |  ------------------
  |  |  |  |   66|    105|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|    105|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|    105|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    105|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|    105|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  113|    105|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  112|    105|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|    105|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:22): [True: 105, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2743|    105|}
mrb_init_string:
 3038|  1.74k|{
 3039|  1.74k|  struct RClass *s;
 3040|       |
 3041|  1.74k|  mrb_static_assert(RSTRING_EMBED_LEN_MAX < (1 << MRB_STR_EMBED_LEN_BIT),
  ------------------
  |  |  109|  1.74k|    mrb_static_assert_expand(mrb_static_assert_selector(__VA_ARGS__, mrb_static_assert2, mrb_static_assert1, _)(__VA_ARGS__))
  |  |  ------------------
  |  |  |  |   99|  1.74k|# define mrb_static_assert_expand(...) __VA_ARGS__ /* for MSVC behaviour - https://stackoverflow.com/q/5530505 */
  |  |  ------------------
  ------------------
 3042|  1.74k|                    "pointer size too big for embedded string");
 3043|       |
 3044|  1.74k|  mrb->string_class = s = mrb_define_class(mrb, "String", mrb->object_class);             /* 15.2.10 */
 3045|  1.74k|  MRB_SET_INSTANCE_TT(s, MRB_TT_STRING);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
 3046|       |
 3047|  1.74k|  mrb_define_method(mrb, s, "bytesize",        mrb_str_bytesize,        MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3048|       |
 3049|  1.74k|  mrb_define_method(mrb, s, "<=>",             mrb_str_cmp_m,           MRB_ARGS_REQ(1)); /* 15.2.10.5.1  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3050|  1.74k|  mrb_define_method(mrb, s, "==",              mrb_str_equal_m,         MRB_ARGS_REQ(1)); /* 15.2.10.5.2  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3051|  1.74k|  mrb_define_method(mrb, s, "+",               mrb_str_plus_m,          MRB_ARGS_REQ(1)); /* 15.2.10.5.4  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3052|  1.74k|  mrb_define_method(mrb, s, "*",               mrb_str_times,           MRB_ARGS_REQ(1)); /* 15.2.10.5.5  */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3053|  1.74k|  mrb_define_method(mrb, s, "[]",              mrb_str_aref_m,          MRB_ARGS_ANY());  /* 15.2.10.5.6  */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3054|  1.74k|  mrb_define_method(mrb, s, "[]=",             mrb_str_aset_m,          MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3055|  1.74k|  mrb_define_method(mrb, s, "capitalize",      mrb_str_capitalize,      MRB_ARGS_NONE()); /* 15.2.10.5.7  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3056|  1.74k|  mrb_define_method(mrb, s, "capitalize!",     mrb_str_capitalize_bang, MRB_ARGS_NONE()); /* 15.2.10.5.8  */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3057|  1.74k|  mrb_define_method(mrb, s, "chomp",           mrb_str_chomp,           MRB_ARGS_ANY());  /* 15.2.10.5.9  */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3058|  1.74k|  mrb_define_method(mrb, s, "chomp!",          mrb_str_chomp_bang,      MRB_ARGS_ANY());  /* 15.2.10.5.10 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3059|  1.74k|  mrb_define_method(mrb, s, "chop",            mrb_str_chop,            MRB_ARGS_NONE()); /* 15.2.10.5.11 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3060|  1.74k|  mrb_define_method(mrb, s, "chop!",           mrb_str_chop_bang,       MRB_ARGS_NONE()); /* 15.2.10.5.12 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3061|  1.74k|  mrb_define_method(mrb, s, "downcase",        mrb_str_downcase,        MRB_ARGS_NONE()); /* 15.2.10.5.13 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3062|  1.74k|  mrb_define_method(mrb, s, "downcase!",       mrb_str_downcase_bang,   MRB_ARGS_NONE()); /* 15.2.10.5.14 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3063|  1.74k|  mrb_define_method(mrb, s, "empty?",          mrb_str_empty_p,         MRB_ARGS_NONE()); /* 15.2.10.5.16 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3064|  1.74k|  mrb_define_method(mrb, s, "eql?",            mrb_str_eql,             MRB_ARGS_REQ(1)); /* 15.2.10.5.17 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3065|       |
 3066|  1.74k|  mrb_define_method(mrb, s, "hash",            mrb_str_hash_m,          MRB_ARGS_NONE()); /* 15.2.10.5.20 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3067|  1.74k|  mrb_define_method(mrb, s, "include?",        mrb_str_include,         MRB_ARGS_REQ(1)); /* 15.2.10.5.21 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3068|  1.74k|  mrb_define_method(mrb, s, "index",           mrb_str_index_m,         MRB_ARGS_ARG(1,1));  /* 15.2.10.5.22 */
  ------------------
  |  | 1813|  1.74k|#define mrb_str_index_m mrb_str_byteindex_m
  ------------------
                mrb_define_method(mrb, s, "index",           mrb_str_index_m,         MRB_ARGS_ARG(1,1));  /* 15.2.10.5.22 */
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3069|  1.74k|  mrb_define_method(mrb, s, "initialize",      mrb_str_init,            MRB_ARGS_REQ(1)); /* 15.2.10.5.23 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3070|  1.74k|  mrb_define_method(mrb, s, "initialize_copy", mrb_str_replace,         MRB_ARGS_REQ(1)); /* 15.2.10.5.24 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3071|  1.74k|  mrb_define_method(mrb, s, "intern",          mrb_str_intern,          MRB_ARGS_NONE()); /* 15.2.10.5.25 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3072|  1.74k|  mrb_define_method(mrb, s, "length",          mrb_str_size,            MRB_ARGS_NONE()); /* 15.2.10.5.26 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3073|  1.74k|  mrb_define_method(mrb, s, "replace",         mrb_str_replace,         MRB_ARGS_REQ(1)); /* 15.2.10.5.28 */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3074|  1.74k|  mrb_define_method(mrb, s, "reverse",         mrb_str_reverse,         MRB_ARGS_NONE()); /* 15.2.10.5.29 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3075|  1.74k|  mrb_define_method(mrb, s, "reverse!",        mrb_str_reverse_bang,    MRB_ARGS_NONE()); /* 15.2.10.5.30 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3076|  1.74k|  mrb_define_method(mrb, s, "rindex",          mrb_str_rindex_m,        MRB_ARGS_ANY());  /* 15.2.10.5.31 */
  ------------------
  |  | 2093|  1.74k|#define mrb_str_rindex_m mrb_str_byterindex_m
  ------------------
                mrb_define_method(mrb, s, "rindex",          mrb_str_rindex_m,        MRB_ARGS_ANY());  /* 15.2.10.5.31 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3077|  1.74k|  mrb_define_method(mrb, s, "size",            mrb_str_size,            MRB_ARGS_NONE()); /* 15.2.10.5.33 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3078|  1.74k|  mrb_define_method(mrb, s, "slice",           mrb_str_aref_m,          MRB_ARGS_ANY());  /* 15.2.10.5.34 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3079|  1.74k|  mrb_define_method(mrb, s, "split",           mrb_str_split_m,         MRB_ARGS_ANY());  /* 15.2.10.5.35 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3080|       |
 3081|  1.74k|#ifndef MRB_NO_FLOAT
 3082|  1.74k|  mrb_define_method(mrb, s, "to_f",            mrb_str_to_f,            MRB_ARGS_NONE()); /* 15.2.10.5.38 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3083|  1.74k|#endif
 3084|  1.74k|  mrb_define_method(mrb, s, "to_i",            mrb_str_to_i,            MRB_ARGS_ANY());  /* 15.2.10.5.39 */
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3085|  1.74k|  mrb_define_method(mrb, s, "to_s",            mrb_str_to_s,            MRB_ARGS_NONE()); /* 15.2.10.5.40 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3086|  1.74k|  mrb_define_method(mrb, s, "to_str",          mrb_str_to_s,            MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3087|  1.74k|  mrb_define_method(mrb, s, "to_sym",          mrb_str_intern,          MRB_ARGS_NONE()); /* 15.2.10.5.41 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3088|  1.74k|  mrb_define_method(mrb, s, "upcase",          mrb_str_upcase,          MRB_ARGS_NONE()); /* 15.2.10.5.42 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3089|  1.74k|  mrb_define_method(mrb, s, "upcase!",         mrb_str_upcase_bang,     MRB_ARGS_NONE()); /* 15.2.10.5.43 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3090|  1.74k|  mrb_define_method(mrb, s, "inspect",         mrb_str_inspect,         MRB_ARGS_NONE()); /* 15.2.10.5.46(x) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3091|  1.74k|  mrb_define_method(mrb, s, "bytes",           mrb_str_bytes,           MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
 3092|       |
 3093|  1.74k|  mrb_define_method(mrb, s, "getbyte",         mrb_str_getbyte,         MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3094|  1.74k|  mrb_define_method(mrb, s, "setbyte",         mrb_str_setbyte,         MRB_ARGS_REQ(2));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3095|  1.74k|  mrb_define_method(mrb, s, "byteindex",       mrb_str_byteindex_m,     MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3096|  1.74k|  mrb_define_method(mrb, s, "byterindex",      mrb_str_byterindex_m,    MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3097|  1.74k|  mrb_define_method(mrb, s, "byteslice",       mrb_str_byteslice,       MRB_ARGS_ARG(1,1));
  ------------------
  |  |  895|  1.74k|#define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  |  |  ------------------
  |  |               #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
  |  |  ------------------
  |  |  |  |  885|  1.74k|#define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
  |  |  ------------------
  ------------------
 3098|  1.74k|  mrb_define_method(mrb, s, "bytesplice",      mrb_str_bytesplice,      MRB_ARGS_ANY());
  ------------------
  |  |  914|  1.74k|#define MRB_ARGS_ANY()      MRB_ARGS_REST()
  |  |  ------------------
  |  |  |  |  898|  1.74k|#define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
  |  |  ------------------
  ------------------
 3099|       |
 3100|  1.74k|  mrb_define_method(mrb, s, "__sub_replace",   sub_replace,             MRB_ARGS_REQ(3)); /* internal */
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
 3101|  1.74k|}
string.c:str_init_embed:
   71|   516k|{
   72|   516k|  mrb_assert(len >= 0);
  ------------------
  |  |   68|   516k|#define mrb_assert(p) ((void)0)
  ------------------
   73|   516k|  if (p) memcpy(RSTR_EMBED_PTR(s), p, len);
  ------------------
  |  |   60|   395k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  ------------------
  |  Branch (73:7): [True: 395k, False: 120k]
  ------------------
   74|   516k|  RSTR_EMBED_PTR(s)[len] = '\0';
  ------------------
  |  |   60|   516k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  ------------------
   75|   516k|  RSTR_SET_TYPE_FLAG(s, EMBED);
  ------------------
  |  |   41|   516k|#define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
  |  |  ------------------
  |  |  |  |   42|   516k|#define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  |  |  ------------------
  |  |  |  |  |  |  115|   516k|#define MRB_STR_TYPE_MASK 15
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|   516k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|   516k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|   516k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   76|   516k|  RSTR_SET_EMBED_LEN(s, len);
  ------------------
  |  |   47|   516k|#define RSTR_SET_EMBED_LEN(s, n) do {\
  |  |   48|   516k|  size_t tmp_n = (n);\
  |  |   49|   516k|  (s)->flags &= ~MRB_STR_EMBED_LEN_MASK;\
  |  |  ------------------
  |  |  |  |  114|   516k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|   516k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  ------------------
  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|   516k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|   516k|  (s)->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
  |  |  ------------------
  |  |  |  |  112|   516k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  ------------------
  |  |   51|   516k|} while (0)
  |  |  ------------------
  |  |  |  Branch (51:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   77|   516k|  return s;
   78|   516k|}
string.c:str_init_normal_capa:
   51|  4.02k|{
   52|  4.02k|  str_check_length(mrb, capa);
   53|  4.02k|  char *dst = (char*)mrb_malloc(mrb, capa + 1);
   54|  4.02k|  if (p) memcpy(dst, p, len);
  ------------------
  |  Branch (54:7): [True: 3.71k, False: 308]
  ------------------
   55|  4.02k|  dst[len] = '\0';
   56|  4.02k|  s->as.heap.ptr = dst;
   57|  4.02k|  s->as.heap.len = len;
   58|  4.02k|  s->as.heap.aux.capa = capa;
   59|  4.02k|  RSTR_UNSET_TYPE_FLAG(s);
  ------------------
  |  |   42|  4.02k|#define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  ------------------
  |  |  |  |  115|  4.02k|#define MRB_STR_TYPE_MASK 15
  |  |  ------------------
  |  |               #define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  ------------------
  |  |  |  |  114|  4.02k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|  4.02k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  ------------------
  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  4.02k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|  4.02k|  return s;
   61|  4.02k|}
string.c:str_new:
  139|   372k|{
  140|   372k|  str_check_length(mrb, len);
  141|   372k|  if (RSTR_EMBEDDABLE_P(len)) {
  ------------------
  |  |   63|   372k|#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
  |  |  ------------------
  |  |  |  |   20|   372k|  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
  |  |  ------------------
  |  |  |  Branch (63:32): [True: 369k, False: 3.69k]
  |  |  ------------------
  ------------------
  142|   369k|    return str_init_embed(mrb_obj_alloc_string(mrb), p, len);
  ------------------
  |  |   29|   369k|#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class)
  |  |  ------------------
  |  |  |  | 1200|   369k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  |  |  ------------------
  ------------------
  143|   369k|  }
  144|  3.69k|  if (p && mrb_ro_data_p(p)) {
  ------------------
  |  Branch (144:7): [True: 3.69k, False: 1]
  |  Branch (144:12): [True: 0, False: 3.69k]
  ------------------
  145|      0|    return str_init_nofree(mrb_obj_alloc_string(mrb), p, len);
  ------------------
  |  |   29|      0|#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class)
  |  |  ------------------
  |  |  |  | 1200|      0|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  |  |  ------------------
  ------------------
  146|      0|  }
  147|  3.69k|  return str_init_normal(mrb, mrb_obj_alloc_string(mrb), p, len);
  ------------------
  |  |   29|  3.69k|#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class)
  |  |  ------------------
  |  |  |  | 1200|  3.69k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  |  |  ------------------
  ------------------
  148|  3.69k|}
string.c:str_init_nofree:
   82|  1.74k|{
   83|  1.74k|  s->as.heap.ptr = (char*)p;
   84|  1.74k|  s->as.heap.len = len;
   85|  1.74k|  s->as.heap.aux.capa = 0;             /* nofree */
   86|  1.74k|  RSTR_SET_TYPE_FLAG(s, NOFREE);
  ------------------
  |  |   41|  1.74k|#define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
  |  |  ------------------
  |  |  |  |   42|  1.74k|#define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  |  |  ------------------
  |  |  |  |  |  |  115|  1.74k|#define MRB_STR_TYPE_MASK 15
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  1.74k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  1.74k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  1.74k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   87|  1.74k|  return s;
   88|  1.74k|}
string.c:str_init_normal:
   65|  3.69k|{
   66|  3.69k|  return str_init_normal_capa(mrb, s, p, len, len);
   67|  3.69k|}
string.c:str_new_static:
  130|  30.1k|{
  131|  30.1k|  if (RSTR_EMBEDDABLE_P(len)) {
  ------------------
  |  |   63|  30.1k|#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
  |  |  ------------------
  |  |  |  |   20|  30.1k|  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
  |  |  ------------------
  |  |  |  Branch (63:32): [True: 28.4k, False: 1.74k]
  |  |  ------------------
  ------------------
  132|  28.4k|    return str_init_embed(mrb_obj_alloc_string(mrb), p, len);
  ------------------
  |  |   29|  28.4k|#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class)
  |  |  ------------------
  |  |  |  | 1200|  28.4k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  |  |  ------------------
  ------------------
  133|  28.4k|  }
  134|  1.74k|  return str_init_nofree(mrb_obj_alloc_string(mrb), p, len);
  ------------------
  |  |   29|  1.74k|#define mrb_obj_alloc_string(mrb) MRB_OBJ_ALLOC((mrb), MRB_TT_STRING, (mrb)->string_class)
  |  |  ------------------
  |  |  |  | 1200|  1.74k|#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass))
  |  |  ------------------
  ------------------
  135|  30.1k|}
string.c:str_decref:
  212|  4.26k|{
  213|  4.26k|  shared->refcnt--;
  214|  4.26k|  if (shared->refcnt == 0) {
  ------------------
  |  Branch (214:7): [True: 2.13k, False: 2.13k]
  ------------------
  215|  2.13k|    mrb_free(mrb, shared->ptr);
  216|  2.13k|    mrb_free(mrb, shared);
  217|  2.13k|  }
  218|  4.26k|}
string.c:str_share:
  512|  2.13k|{
  513|  2.13k|  size_t len = (size_t)orig->as.heap.len;
  514|       |
  515|  2.13k|  mrb_assert(!RSTR_EMBED_P(orig));
  ------------------
  |  |   68|  2.13k|#define mrb_assert(p) ((void)0)
  ------------------
  516|  2.13k|  if (RSTR_NOFREE_P(orig)) {
  ------------------
  |  |   77|  2.13k|#define RSTR_NOFREE_P(s) ((s)->flags & MRB_STR_NOFREE)
  |  |  ------------------
  |  |  |  |  109|  2.13k|#define MRB_STR_NOFREE    4
  |  |  ------------------
  |  |  |  Branch (77:26): [True: 0, False: 2.13k]
  |  |  ------------------
  ------------------
  517|      0|    str_init_nofree(s, orig->as.heap.ptr, len);
  518|      0|  }
  519|  2.13k|  else if (RSTR_SHARED_P(orig)) {
  ------------------
  |  |   69|  2.13k|#define RSTR_SHARED_P(s) ((s)->flags & MRB_STR_SHARED)
  |  |  ------------------
  |  |  |  |  107|  2.13k|#define MRB_STR_SHARED    1
  |  |  ------------------
  |  |  |  Branch (69:26): [True: 0, False: 2.13k]
  |  |  ------------------
  ------------------
  520|      0|    str_init_shared(mrb, orig, s, orig->as.heap.aux.shared);
  521|      0|  }
  522|  2.13k|  else if (RSTR_FSHARED_P(orig)) {
  ------------------
  |  |   73|  2.13k|#define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
  |  |  ------------------
  |  |  |  |  108|  2.13k|#define MRB_STR_FSHARED   2
  |  |  ------------------
  |  |  |  Branch (73:27): [True: 0, False: 2.13k]
  |  |  ------------------
  ------------------
  523|      0|    str_init_fshared(orig, s, orig->as.heap.aux.fshared);
  524|      0|  }
  525|  2.13k|  else {
  526|  2.13k|    if (orig->as.heap.aux.capa > orig->as.heap.len) {
  ------------------
  |  Branch (526:9): [True: 0, False: 2.13k]
  ------------------
  527|      0|      orig->as.heap.ptr = (char*)mrb_realloc(mrb, orig->as.heap.ptr, len+1);
  528|      0|      orig->as.heap.aux.capa = (mrb_ssize)len;
  529|      0|    }
  530|  2.13k|    str_init_shared(mrb, orig, s, NULL);
  531|  2.13k|    str_init_shared(mrb, orig, orig, s->as.heap.aux.shared);
  532|  2.13k|  }
  533|  2.13k|}
string.c:str_init_shared:
   92|  4.26k|{
   93|  4.26k|  if (shared) {
  ------------------
  |  Branch (93:7): [True: 2.13k, False: 2.13k]
  ------------------
   94|  2.13k|    shared->refcnt++;
   95|  2.13k|  }
   96|  2.13k|  else {
   97|  2.13k|    shared = (mrb_shared_string*)mrb_malloc(mrb, sizeof(mrb_shared_string));
   98|  2.13k|    shared->refcnt = 1;
   99|  2.13k|    shared->ptr = orig->as.heap.ptr;
  100|  2.13k|    shared->capa = orig->as.heap.aux.capa;
  101|  2.13k|  }
  102|  4.26k|  s->as.heap.ptr = orig->as.heap.ptr;
  103|  4.26k|  s->as.heap.len = orig->as.heap.len;
  104|  4.26k|  s->as.heap.aux.shared = shared;
  105|  4.26k|  RSTR_SET_TYPE_FLAG(s, SHARED);
  ------------------
  |  |   41|  4.26k|#define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
  |  |  ------------------
  |  |  |  |   42|  4.26k|#define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  |  |  ------------------
  |  |  |  |  |  |  115|  4.26k|#define MRB_STR_TYPE_MASK 15
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_UNSET_TYPE_FLAG(s) ((s)->flags &= ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK))
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  4.26k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  4.26k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  4.26k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  106|  4.26k|  return s;
  107|  4.26k|}
string.c:str_modify_keep_ascii:
  222|  32.5k|{
  223|  32.5k|  if (RSTR_SHARED_P(s)) {
  ------------------
  |  |   69|  32.5k|#define RSTR_SHARED_P(s) ((s)->flags & MRB_STR_SHARED)
  |  |  ------------------
  |  |  |  |  107|  32.5k|#define MRB_STR_SHARED    1
  |  |  ------------------
  |  |  |  Branch (69:26): [True: 0, False: 32.5k]
  |  |  ------------------
  ------------------
  224|      0|    mrb_shared_string *shared = s->as.heap.aux.shared;
  225|       |
  226|      0|    if (shared->refcnt == 1 && s->as.heap.ptr == shared->ptr) {
  ------------------
  |  Branch (226:9): [True: 0, False: 0]
  |  Branch (226:32): [True: 0, False: 0]
  ------------------
  227|      0|      s->as.heap.aux.capa = shared->capa;
  228|      0|      s->as.heap.ptr[s->as.heap.len] = '\0';
  229|      0|      RSTR_UNSET_SHARED_FLAG(s);
  ------------------
  |  |   71|      0|#define RSTR_UNSET_SHARED_FLAG(s) ((s)->flags &= ~MRB_STR_SHARED)
  |  |  ------------------
  |  |  |  |  107|      0|#define MRB_STR_SHARED    1
  |  |  ------------------
  ------------------
  230|      0|      mrb_free(mrb, shared);
  231|      0|    }
  232|      0|    else {
  233|      0|      str_init_modifiable(mrb, s, s->as.heap.ptr, s->as.heap.len);
  234|      0|      str_decref(mrb, shared);
  235|      0|    }
  236|      0|  }
  237|  32.5k|  else if (RSTR_NOFREE_P(s) || RSTR_FSHARED_P(s)) {
  ------------------
  |  |   77|  65.1k|#define RSTR_NOFREE_P(s) ((s)->flags & MRB_STR_NOFREE)
  |  |  ------------------
  |  |  |  |  109|  32.5k|#define MRB_STR_NOFREE    4
  |  |  ------------------
  |  |  |  Branch (77:26): [True: 0, False: 32.5k]
  |  |  ------------------
  ------------------
                else if (RSTR_NOFREE_P(s) || RSTR_FSHARED_P(s)) {
  ------------------
  |  |   73|  32.5k|#define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
  |  |  ------------------
  |  |  |  |  108|  32.5k|#define MRB_STR_FSHARED   2
  |  |  ------------------
  |  |  |  Branch (73:27): [True: 0, False: 32.5k]
  |  |  ------------------
  ------------------
  238|      0|    str_init_modifiable(mrb, s, s->as.heap.ptr, s->as.heap.len);
  239|      0|  }
  240|  32.5k|}
string.c:str_check_length:
   37|   376k|{
   38|   376k|  if (len < 0) {
  ------------------
  |  Branch (38:7): [True: 0, False: 376k]
  ------------------
   39|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "negative (or overflowed) string size");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   40|      0|  }
   41|   376k|#if MRB_STR_LENGTH_MAX != 0
   42|   376k|  if (len > MRB_STR_LENGTH_MAX-1) {
  ------------------
  |  |   32|   376k|#define MRB_STR_LENGTH_MAX 1048576
  ------------------
  |  Branch (42:7): [True: 0, False: 376k]
  ------------------
   43|      0|    mrb_raisef(mrb, E_ARGUMENT_ERROR, "string too long (len=%i max=" MRB_STRINGIZE(MRB_STR_LENGTH_MAX) ")", len);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   44|      0|  }
   45|   376k|#endif
   46|   376k|}
string.c:resize_capa:
  166|     21|{
  167|     21|  if (RSTR_EMBED_P(s)) {
  ------------------
  |  |   44|     21|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  ------------------
  |  |  |  |  110|     21|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  ------------------
  |  |  |  Branch (44:25): [True: 21, False: 0]
  |  |  ------------------
  ------------------
  168|     21|    if (!RSTR_EMBEDDABLE_P(capacity)) {
  ------------------
  |  |   63|     21|#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
  |  |  ------------------
  |  |  |  |   20|     21|  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
  |  |  ------------------
  ------------------
  |  Branch (168:9): [True: 21, False: 0]
  ------------------
  169|     21|      str_init_normal_capa(mrb, s, RSTR_EMBED_PTR(s), RSTR_EMBED_LEN(s), capacity);
  ------------------
  |  |   60|     21|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  ------------------
                    str_init_normal_capa(mrb, s, RSTR_EMBED_PTR(s), RSTR_EMBED_LEN(s), capacity);
  ------------------
  |  |   62|     21|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  ------------------
  |  |  |  |  114|     21|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|     21|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  ------------------
  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|     21|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  ------------------
  |  |  |  |  112|     21|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  ------------------
  ------------------
  170|     21|    }
  171|     21|  }
  172|      0|  else {
  173|      0|    str_check_length(mrb, capacity);
  174|      0|    s->as.heap.ptr = (char*)mrb_realloc(mrb, RSTR_PTR(s), capacity+1);
  ------------------
  |  |   65|      0|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|      0|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|      0|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  175|      0|    s->as.heap.aux.capa = (mrb_ssize)capacity;
  176|      0|  }
  177|     21|}
string.c:check_null_byte:
  244|  5.23k|{
  245|  5.23k|  if (memchr(RSTR_PTR(str), '\0', RSTR_LEN(str))) {
  ------------------
  |  |   65|  5.23k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|  5.23k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  5.23k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|  5.23k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 5.23k, False: 0]
  |  |  ------------------
  ------------------
                if (memchr(RSTR_PTR(str), '\0', RSTR_LEN(str))) {
  ------------------
  |  |   66|  5.23k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|  5.23k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|  5.23k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|  5.23k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|  5.23k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  5.23k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  5.23k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  5.23k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 5.23k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (245:7): [True: 0, False: 5.23k]
  ------------------
  246|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  247|      0|  }
  248|  5.23k|}
string.c:str_eql:
  982|   113k|{
  983|   113k|  const mrb_int len = RSTRING_LEN(str1);
  ------------------
  |  |  102|   113k|#define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
  |  |  ------------------
  |  |  |  |   66|   113k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|   113k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|   113k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   112k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|   112k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  113|   112k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  112|   112k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|   112k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:22): [True: 112k, False: 1.35k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  984|       |
  985|   113k|  if (len != RSTRING_LEN(str2)) return FALSE;
  ------------------
  |  |  102|   113k|#define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
  |  |  ------------------
  |  |  |  |   66|   113k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|   113k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|   113k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|   112k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|   112k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  113|   112k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  112|   112k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|   112k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:22): [True: 112k, False: 1.11k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (len != RSTRING_LEN(str2)) return FALSE;
  ------------------
  |  |   51|  9.96k|#  define FALSE 0
  ------------------
  |  Branch (985:7): [True: 9.96k, False: 103k]
  ------------------
  986|   103k|  if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), (size_t)len) == 0)
  ------------------
  |  |  100|   103k|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|   103k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|   103k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|   103k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|   103k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 103k, False: 356]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), (size_t)len) == 0)
  ------------------
  |  |  100|   103k|#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
  |  |  ------------------
  |  |  |  |   65|   103k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   44|   103k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  110|   103k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|   103k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:22): [True: 103k, False: 356]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (986:7): [True: 102k, False: 1.09k]
  ------------------
  987|   102k|    return TRUE;
  ------------------
  |  |   54|   102k|#  define TRUE 1
  ------------------
  988|  1.09k|  return FALSE;
  ------------------
  |  |   51|  1.09k|#  define FALSE 0
  ------------------
  989|   103k|}
string.c:str_replace:
  633|   120k|{
  634|   120k|  size_t len;
  635|       |
  636|   120k|  mrb_check_frozen(mrb, s1);
  637|   120k|  if (s1 == s2) return mrb_obj_value(s1);
  ------------------
  |  Branch (637:7): [True: 0, False: 120k]
  ------------------
  638|   120k|  RSTR_COPY_ASCII_FLAG(s1, s2);
  ------------------
  |  |   92|   120k|# define RSTR_COPY_ASCII_FLAG(dst, src) (void)0
  ------------------
  639|   120k|  if (RSTR_SHARED_P(s1)) {
  ------------------
  |  |   69|   120k|#define RSTR_SHARED_P(s) ((s)->flags & MRB_STR_SHARED)
  |  |  ------------------
  |  |  |  |  107|   120k|#define MRB_STR_SHARED    1
  |  |  ------------------
  |  |  |  Branch (69:26): [True: 0, False: 120k]
  |  |  ------------------
  ------------------
  640|      0|    str_decref(mrb, s1->as.heap.aux.shared);
  641|      0|  }
  642|   120k|  else if (!RSTR_EMBED_P(s1) && !RSTR_NOFREE_P(s1) && !RSTR_FSHARED_P(s1)
  ------------------
  |  |   44|   241k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  ------------------
  |  |  |  |  110|   120k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  ------------------
  ------------------
                else if (!RSTR_EMBED_P(s1) && !RSTR_NOFREE_P(s1) && !RSTR_FSHARED_P(s1)
  ------------------
  |  |   77|   120k|#define RSTR_NOFREE_P(s) ((s)->flags & MRB_STR_NOFREE)
  |  |  ------------------
  |  |  |  |  109|      0|#define MRB_STR_NOFREE    4
  |  |  ------------------
  ------------------
                else if (!RSTR_EMBED_P(s1) && !RSTR_NOFREE_P(s1) && !RSTR_FSHARED_P(s1)
  ------------------
  |  |   73|   120k|#define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
  |  |  ------------------
  |  |  |  |  108|      0|#define MRB_STR_FSHARED   2
  |  |  ------------------
  ------------------
  |  Branch (642:12): [True: 0, False: 120k]
  |  Branch (642:33): [True: 0, False: 0]
  |  Branch (642:55): [True: 0, False: 0]
  ------------------
  643|   120k|           && s1->as.heap.ptr) {
  ------------------
  |  Branch (643:15): [True: 0, False: 0]
  ------------------
  644|      0|    mrb_free(mrb, s1->as.heap.ptr);
  645|      0|  }
  646|       |
  647|   120k|  len = (size_t)RSTR_LEN(s2);
  ------------------
  |  |   66|   120k|#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   44|   120k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|   120k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
  |  |  ------------------
  |  |  |  |   62|   118k|  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|   118k|#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|   118k|#define MRB_STR_EMBED_LEN_BIT 5
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|   118k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|   118k|#define MRB_STR_EMBED_LEN_SHIFT 6
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (66:22): [True: 118k, False: 2.13k]
  |  |  ------------------
  ------------------
  648|   120k|  if (RSTR_EMBEDDABLE_P(len)) {
  ------------------
  |  |   63|   120k|#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
  |  |  ------------------
  |  |  |  |   20|   120k|  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
  |  |  ------------------
  |  |  |  Branch (63:32): [True: 118k, False: 2.13k]
  |  |  ------------------
  ------------------
  649|   118k|    str_init_embed(s1, RSTR_PTR(s2), len);
  ------------------
  |  |   65|   118k|#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   44|   118k|#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|   118k|#define MRB_STR_EMBED     8  /* type flags up to here */
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   60|   118k|#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
  |  |  ------------------
  |  |  |  Branch (65:22): [True: 118k, False: 0]
  |  |  ------------------
  ------------------
  650|   118k|  }
  651|  2.13k|  else {
  652|  2.13k|    str_share(mrb, s2, s1);
  653|  2.13k|  }
  654|       |
  655|   120k|  return mrb_obj_value(s1);
  656|   120k|}

mrb_intern:
  240|  2.33M|{
  241|  2.33M|  return sym_intern(mrb, name, len, FALSE);
  ------------------
  |  |   51|  2.33M|#  define FALSE 0
  ------------------
  242|  2.33M|}
mrb_intern_static:
  246|  12.2k|{
  247|  12.2k|  return sym_intern(mrb, name, len, TRUE);
  ------------------
  |  |   54|  12.2k|#  define TRUE 1
  ------------------
  248|  12.2k|}
mrb_intern_cstr:
  252|  1.80M|{
  253|  1.80M|  return mrb_intern(mrb, name, strlen(name));
  254|  1.80M|}
mrb_sym_name_len:
  342|   320k|{
  343|       |#ifdef MRB_USE_ALL_SYMBOLS
  344|       |  return sym2name_len(mrb, sym, NULL, lenp);
  345|       |#else
  346|   320k|  return sym2name_len(mrb, sym, mrb->symbuf, lenp);
  347|   320k|#endif
  348|   320k|}
mrb_free_symtbl:
  352|  1.74k|{
  353|  1.74k|  mrb_sym i, lim;
  354|       |
  355|   160k|  for (i=1, lim=mrb->symidx+1; i<lim; i++) {
  ------------------
  |  Branch (355:32): [True: 158k, False: 1.74k]
  ------------------
  356|   158k|    if (!sym_lit_p(mrb, i)) {
  ------------------
  |  |  122|   158k|#define sym_lit_p(mrb, i) (mrb->symflags[i>>3]&(1<<(i&7)))
  ------------------
  |  Branch (356:9): [True: 158k, False: 0]
  ------------------
  357|   158k|      mrb_free(mrb, (char*)mrb->symtbl[i]);
  358|   158k|    }
  359|   158k|  }
  360|  1.74k|  mrb_free(mrb, (void*)mrb->symtbl);
  361|  1.74k|  mrb_free(mrb, (void*)mrb->symlink);
  362|  1.74k|  mrb_free(mrb, (void*)mrb->symflags);
  363|  1.74k|}
mrb_init_symtbl:
  367|  1.74k|{
  368|  1.74k|}
mrb_sym_str:
  615|  15.9k|{
  616|  15.9k|  mrb_int len;
  617|  15.9k|  const char *name = mrb_sym_name_len(mrb, sym, &len);
  618|       |
  619|  15.9k|  if (!name) return mrb_undef_value(); /* can't happen */
  ------------------
  |  Branch (619:7): [True: 0, False: 15.9k]
  ------------------
  620|  15.9k|  if (SYMBOL_INLINE_P(sym)) {
  ------------------
  |  |   70|  15.9k|# define SYMBOL_INLINE_P(sym) ((sym) >= (1<<24))
  |  |  ------------------
  |  |  |  Branch (70:31): [True: 0, False: 15.9k]
  |  |  ------------------
  ------------------
  621|      0|    mrb_value str = mrb_str_new(mrb, name, len);
  622|      0|    RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
  ------------------
  |  |   89|      0|# define RSTR_SET_ASCII_FLAG(s) (void)0
  ------------------
  623|      0|    return str;
  624|      0|  }
  625|  15.9k|  return mrb_str_new_static(mrb, name, len);
  626|  15.9k|}
mrb_init_symbol:
  691|  1.74k|{
  692|  1.74k|  struct RClass *sym;
  693|       |
  694|  1.74k|  mrb->symbol_class = sym = mrb_define_class(mrb, "Symbol", mrb->object_class);  /* 15.2.11 */
  695|  1.74k|  MRB_SET_INSTANCE_TT(sym, MRB_TT_SYMBOL);
  ------------------
  |  |   75|  1.74k|#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
  |  |  ------------------
  |  |  |  |   74|  1.74k|#define MRB_INSTANCE_TT_MASK (0x1F)
  |  |  ------------------
  ------------------
  696|  1.74k|  mrb_undef_class_method(mrb,  sym, "new");
  697|       |
  698|  1.74k|  mrb_define_method(mrb, sym, "to_s",    sym_to_s,    MRB_ARGS_NONE());          /* 15.2.11.3.3 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  699|  1.74k|  mrb_define_method(mrb, sym, "name",    sym_name,    MRB_ARGS_NONE());
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  700|  1.74k|  mrb_define_method(mrb, sym, "to_sym",  sym_to_sym,  MRB_ARGS_NONE());          /* 15.2.11.3.4 */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  701|  1.74k|  mrb_define_method(mrb, sym, "inspect", sym_inspect, MRB_ARGS_NONE());          /* 15.2.11.3.5(x) */
  ------------------
  |  |  919|  1.74k|#define MRB_ARGS_NONE()     ((mrb_aspec)0)
  ------------------
  702|  1.74k|  mrb_define_method(mrb, sym, "<=>",     sym_cmp,     MRB_ARGS_REQ(1));
  ------------------
  |  |  877|  1.74k|#define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
  ------------------
  703|  1.74k|}
symbol.c:sym_intern:
  189|  2.34M|{
  190|  2.34M|  mrb_sym sym;
  191|  2.34M|  uint8_t hash;
  192|       |
  193|  2.34M|  sym_validate_len(mrb, len);
  194|  2.34M|  sym = find_symbol(mrb, name, len, &hash);
  195|  2.34M|  if (sym > 0) return sym;
  ------------------
  |  Branch (195:7): [True: 2.18M, False: 158k]
  ------------------
  196|       |
  197|       |  /* registering a new symbol */
  198|   158k|  sym = mrb->symidx + 1;
  199|   158k|  if (mrb->symcapa <= sym) {
  ------------------
  |  Branch (199:7): [True: 4.41k, False: 154k]
  ------------------
  200|  4.41k|    size_t symcapa = mrb->symcapa;
  201|  4.41k|    if (symcapa == 0) symcapa = 100;
  ------------------
  |  Branch (201:9): [True: 1.74k, False: 2.67k]
  ------------------
  202|  2.67k|    else symcapa = (size_t)(symcapa * 6 / 5);
  203|  4.41k|    mrb->symtbl = (const char**)mrb_realloc(mrb, (void*)mrb->symtbl, sizeof(char*)*symcapa);
  204|  4.41k|    mrb->symflags = (uint8_t*)mrb_realloc(mrb, mrb->symflags, symcapa/8+1);
  205|  4.41k|    memset(mrb->symflags+mrb->symcapa/8+1, 0, (symcapa-mrb->symcapa)/8);
  206|  4.41k|    mrb->symlink = (uint8_t*)mrb_realloc(mrb, mrb->symlink, symcapa);
  207|  4.41k|    mrb->symcapa = symcapa;
  208|  4.41k|  }
  209|   158k|  sym_flags_clear(mrb, sym);
  ------------------
  |  |  124|   158k|#define sym_flags_clear(mrb, i) mrb->symflags[i>>3]&=~(1<<(i&7))
  ------------------
  210|   158k|  if ((lit || mrb_ro_data_p(name)) && name[len] == 0 && strlen(name) == len) {
  ------------------
  |  Branch (210:8): [True: 0, False: 158k]
  |  Branch (210:15): [True: 0, False: 158k]
  |  Branch (210:39): [True: 0, False: 0]
  |  Branch (210:57): [True: 0, False: 0]
  ------------------
  211|      0|    sym_lit_set(mrb, sym);
  ------------------
  |  |  123|      0|#define sym_lit_set(mrb, i) mrb->symflags[i>>3]|=(1<<(i&7))
  ------------------
  212|      0|    mrb->symtbl[sym] = name;
  213|      0|  }
  214|   158k|  else {
  215|   158k|    uint32_t ulen = (uint32_t)len;
  216|   158k|    size_t ilen = mrb_packed_int_len(ulen);
  217|   158k|    char *p = (char*)mrb_malloc(mrb, len+ilen+1);
  218|   158k|    mrb_packed_int_encode(ulen, (uint8_t*)p, (uint8_t*)p+ilen);
  219|   158k|    memcpy(p+ilen, name, len);
  220|   158k|    p[ilen+len] = 0;
  221|   158k|    mrb->symtbl[sym] = p;
  222|   158k|  }
  223|   158k|  if (mrb->symhash[hash]) {
  ------------------
  |  Branch (223:7): [True: 68.4k, False: 89.9k]
  ------------------
  224|  68.4k|    mrb_sym i = sym - mrb->symhash[hash];
  225|  68.4k|    if (i > 0xff)
  ------------------
  |  Branch (225:9): [True: 10.6k, False: 57.8k]
  ------------------
  226|  10.6k|      mrb->symlink[sym] = 0xff;
  227|  57.8k|    else
  228|  57.8k|      mrb->symlink[sym] = i;
  229|  68.4k|  }
  230|  89.9k|  else {
  231|  89.9k|    mrb->symlink[sym] = 0;
  232|  89.9k|  }
  233|   158k|  mrb->symhash[hash] = mrb->symidx = sym;
  234|       |
  235|   158k|  return (sym+MRB_PRESYM_MAX);
  ------------------
  |  | 1451|   158k|#define MRB_PRESYM_MAX 1453
  ------------------
  236|  2.34M|}
symbol.c:sym_validate_len:
   59|  2.34M|{
   60|  2.34M|  if (len >= UINT16_MAX) {
  ------------------
  |  Branch (60:7): [True: 0, False: 2.34M]
  ------------------
   61|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "symbol length too long");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|      0|  }
   63|  2.34M|}
symbol.c:find_symbol:
  147|  2.34M|{
  148|  2.34M|  mrb_sym i;
  149|  2.34M|  uint8_t hash;
  150|       |
  151|  2.34M|#ifndef MRB_NO_PRESYM
  152|       |  /* presym */
  153|  2.34M|  i = presym_find(name, len);
  154|  2.34M|  if (i > 0) return i;
  ------------------
  |  Branch (154:7): [True: 2.01M, False: 331k]
  ------------------
  155|   331k|#endif
  156|       |
  157|       |  /* inline symbol */
  158|   331k|  i = sym_inline_pack(name, len);
  159|   331k|  if (i > 0) return i;
  ------------------
  |  Branch (159:7): [True: 90.0k, False: 241k]
  ------------------
  160|       |
  161|   241k|  hash = mrb_byte_hash((const uint8_t*)name, len);
  162|   241k|  if (hashp) *hashp = hash;
  ------------------
  |  Branch (162:7): [True: 241k, False: 0]
  ------------------
  163|       |
  164|   241k|  i = mrb->symhash[hash];
  165|   241k|  if (i == 0) return 0;
  ------------------
  |  Branch (165:7): [True: 89.9k, False: 151k]
  ------------------
  166|   231k|  for (;;) {
  167|   231k|    if (sym_check(mrb, name, len, i)) {
  ------------------
  |  Branch (167:9): [True: 80.8k, False: 150k]
  ------------------
  168|  80.8k|      return (i+MRB_PRESYM_MAX);
  ------------------
  |  | 1451|  80.8k|#define MRB_PRESYM_MAX 1453
  ------------------
  169|  80.8k|    }
  170|   150k|    uint8_t diff = mrb->symlink[i];
  171|   150k|    if (diff == 0xff) {
  ------------------
  |  Branch (171:9): [True: 24.9k, False: 125k]
  ------------------
  172|  24.9k|      i -= 0xff;
  173|  41.1M|      while (i > 0) {
  ------------------
  |  Branch (173:14): [True: 41.1M, False: 22.9k]
  ------------------
  174|  41.1M|        if (sym_check(mrb, name, len, i)) {
  ------------------
  |  Branch (174:13): [True: 1.99k, False: 41.1M]
  ------------------
  175|  1.99k|          return (i+MRB_PRESYM_MAX);
  ------------------
  |  | 1451|  1.99k|#define MRB_PRESYM_MAX 1453
  ------------------
  176|  1.99k|        }
  177|  41.1M|        i--;
  178|  41.1M|      }
  179|  22.9k|      return 0;
  180|  24.9k|    }
  181|   125k|    if (diff == 0) return 0;
  ------------------
  |  Branch (181:9): [True: 45.5k, False: 80.3k]
  ------------------
  182|  80.3k|    i -= diff;
  183|  80.3k|  }
  184|      0|  return 0;
  185|   151k|}
symbol.c:presym_find:
   26|  2.34M|{
   27|  2.34M|  if (presym_length_table[MRB_PRESYM_MAX-1] < len) return 0;
  ------------------
  |  | 1451|  2.34M|#define MRB_PRESYM_MAX 1453
  ------------------
  |  Branch (27:7): [True: 0, False: 2.34M]
  ------------------
   28|       |
   29|  2.34M|  mrb_sym start, idx, presym_size = MRB_PRESYM_MAX;
  ------------------
  |  | 1451|  2.34M|#define MRB_PRESYM_MAX 1453
  ------------------
   30|  2.34M|  int cmp;
   31|  23.3M|  for (start = 0; presym_size != 0; presym_size/=2) {
  ------------------
  |  Branch (31:19): [True: 23.0M, False: 331k]
  ------------------
   32|  23.0M|    idx = start+presym_size/2;
   33|  23.0M|    cmp = (int)len-(int)presym_length_table[idx];
   34|  23.0M|    if (cmp == 0) {
  ------------------
  |  Branch (34:9): [True: 14.4M, False: 8.56M]
  ------------------
   35|  14.4M|      cmp = memcmp(name, presym_name_table[idx], len);
   36|  14.4M|      if (cmp == 0) return idx+1;
  ------------------
  |  Branch (36:11): [True: 2.01M, False: 12.4M]
  ------------------
   37|  14.4M|    }
   38|  21.0M|    if (0 < cmp) {
  ------------------
  |  Branch (38:9): [True: 9.17M, False: 11.8M]
  ------------------
   39|  9.17M|      start = ++idx;
   40|  9.17M|      --presym_size;
   41|  9.17M|    }
   42|  21.0M|  }
   43|   331k|  return 0;
   44|  2.34M|}
symbol.c:sym_inline_pack:
   76|   331k|{
   77|       |#if defined(MRB_WORD_BOXING) && defined(MRB_32BIT) && !defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
   78|       |  const size_t pack_length_max = 4;
   79|       |#else
   80|   331k|  const size_t pack_length_max = 5;
   81|   331k|#endif
   82|       |
   83|   331k|  char c;
   84|   331k|  const char *p;
   85|   331k|  size_t i;
   86|   331k|  mrb_sym sym = 0;
   87|       |
   88|   331k|  if (len > pack_length_max) return 0; /* too long */
  ------------------
  |  Branch (88:7): [True: 236k, False: 95.3k]
  ------------------
   89|  95.3k|  if (len == 0) return 0; /* empty string */
  ------------------
  |  Branch (89:7): [True: 0, False: 95.3k]
  ------------------
   90|   557k|  for (i=0; i<len; i++) {
  ------------------
  |  Branch (90:13): [True: 467k, False: 90.0k]
  ------------------
   91|   467k|    uint32_t bits;
   92|       |
   93|   467k|    c = name[i];
   94|   467k|    if (c == 0) return 0;       /* NUL in name */
  ------------------
  |  Branch (94:9): [True: 0, False: 467k]
  ------------------
   95|   467k|    p = strchr(pack_table, (int)c);
   96|   467k|    if (p == 0) return 0;       /* non alnum char */
  ------------------
  |  Branch (96:9): [True: 5.23k, False: 462k]
  ------------------
   97|   462k|    bits = (uint32_t)(p - pack_table)+1;
   98|   462k|    sym |= bits<<(24-i*6);
   99|   462k|  }
  100|  90.0k|  mrb_assert(SYMBOL_INLINE_P(sym));
  ------------------
  |  |   68|  90.0k|#define mrb_assert(p) ((void)0)
  ------------------
  101|  90.0k|  return sym;
  102|  95.3k|}
symbol.c:sym_check:
  128|  41.3M|{
  129|  41.3M|  const char *symname = mrb->symtbl[i];
  130|  41.3M|  size_t symlen;
  131|       |
  132|  41.3M|  if (sym_lit_p(mrb, i)) {
  ------------------
  |  |  122|  41.3M|#define sym_lit_p(mrb, i) (mrb->symflags[i>>3]&(1<<(i&7)))
  |  |  ------------------
  |  |  |  Branch (122:27): [True: 0, False: 41.3M]
  |  |  ------------------
  ------------------
  133|      0|    symlen = strlen(symname);
  134|      0|  }
  135|  41.3M|  else {
  136|       |    /* length in BER */
  137|  41.3M|    symlen = mrb_packed_int_decode((const uint8_t*)symname, (const uint8_t**)&symname);
  138|  41.3M|  }
  139|  41.3M|  if (len == symlen && memcmp(symname, name, len) == 0) {
  ------------------
  |  Branch (139:7): [True: 21.3M, False: 20.0M]
  |  Branch (139:24): [True: 82.8k, False: 21.2M]
  ------------------
  140|  82.8k|    return TRUE;
  ------------------
  |  |   54|  82.8k|#  define TRUE 1
  ------------------
  141|  82.8k|  }
  142|  41.2M|  return FALSE;
  ------------------
  |  |   51|  41.2M|#  define FALSE 0
  ------------------
  143|  41.3M|}
symbol.c:sym2name_len:
  311|   320k|{
  312|   320k|  if (sym == 0) goto outofsym;
  ------------------
  |  Branch (312:7): [True: 0, False: 320k]
  ------------------
  313|   320k|  if (SYMBOL_INLINE_P(sym)) return sym_inline_unpack(sym, buf, lenp);
  ------------------
  |  |   70|   320k|# define SYMBOL_INLINE_P(sym) ((sym) >= (1<<24))
  |  |  ------------------
  |  |  |  Branch (70:31): [True: 0, False: 320k]
  |  |  ------------------
  ------------------
  314|       |
  315|   320k|#ifndef MRB_NO_PRESYM
  316|   320k|  {
  317|   320k|    const char *name = presym_sym2name(sym, lenp);
  318|   320k|    if (name) return name;
  ------------------
  |  Branch (318:9): [True: 317k, False: 3.49k]
  ------------------
  319|   320k|  }
  320|  3.49k|#endif
  321|  3.49k|  sym -= MRB_PRESYM_MAX;
  ------------------
  |  | 1451|  3.49k|#define MRB_PRESYM_MAX 1453
  ------------------
  322|       |
  323|  3.49k|  if (mrb->symidx < sym) {
  ------------------
  |  Branch (323:7): [True: 0, False: 3.49k]
  ------------------
  324|      0|  outofsym:
  325|      0|    if (lenp) *lenp = 0;
  ------------------
  |  Branch (325:9): [True: 0, False: 0]
  ------------------
  326|      0|    return NULL;
  327|      0|  }
  328|       |
  329|  3.49k|  const char *symname = mrb->symtbl[sym];
  330|  3.49k|  if (!sym_lit_p(mrb, sym)) {
  ------------------
  |  |  122|  3.49k|#define sym_lit_p(mrb, i) (mrb->symflags[i>>3]&(1<<(i&7)))
  ------------------
  |  Branch (330:7): [True: 3.49k, False: 0]
  ------------------
  331|  3.49k|    uint32_t len = mrb_packed_int_decode((const uint8_t*)symname, (const uint8_t**)&symname);
  332|  3.49k|    if (lenp) *lenp = (mrb_int)len;
  ------------------
  |  Branch (332:9): [True: 3.49k, False: 0]
  ------------------
  333|  3.49k|  }
  334|      0|  else if (lenp) {
  ------------------
  |  Branch (334:12): [True: 0, False: 0]
  ------------------
  335|      0|    *lenp = (mrb_int)strlen(symname);
  336|      0|  }
  337|  3.49k|  return symname;
  338|  3.49k|}
symbol.c:presym_sym2name:
   48|   320k|{
   49|   320k|  if (sym > MRB_PRESYM_MAX) return NULL;
  ------------------
  |  | 1451|   320k|#define MRB_PRESYM_MAX 1453
  ------------------
  |  Branch (49:7): [True: 3.49k, False: 317k]
  ------------------
   50|   317k|  if (lenp) *lenp = presym_length_table[sym-1];
  ------------------
  |  Branch (50:7): [True: 161k, False: 155k]
  ------------------
   51|   317k|  return presym_name_table[sym-1];
   52|   320k|}

vm.c:value_move:
    8|  66.3k|{
    9|  66.3k|  if (n == 0) return;
  ------------------
  |  Branch (9:7): [True: 30.1k, False: 36.2k]
  ------------------
   10|  36.2k|  if (s1 > s2 && s1 < s2 + n)
  ------------------
  |  Branch (10:7): [True: 6.94k, False: 29.2k]
  |  Branch (10:18): [True: 0, False: 6.94k]
  ------------------
   11|      0|  {
   12|      0|    s1 += n;
   13|      0|    s2 += n;
   14|      0|    while (n-- > 0) {
  ------------------
  |  Branch (14:12): [True: 0, False: 0]
  ------------------
   15|      0|      *--s1 = *--s2;
   16|      0|    }
   17|      0|  }
   18|  36.2k|  else if (s1 != s2) {
  ------------------
  |  Branch (18:12): [True: 36.2k, False: 0]
  ------------------
   19|  97.3k|    while (n-- > 0) {
  ------------------
  |  Branch (19:12): [True: 61.0k, False: 36.2k]
  ------------------
   20|  61.0k|      *s1++ = *s2++;
   21|  61.0k|    }
   22|  36.2k|  }
   23|      0|  else {
   24|       |    /* nothing to do. */
   25|      0|  }
   26|  36.2k|}

mrb_gc_mark_gv:
  250|  36.4k|{
  251|  36.4k|  mark_tbl(mrb, mrb->globals);
  252|  36.4k|}
mrb_gc_free_gv:
  256|  1.74k|{
  257|  1.74k|  if (mrb->globals)
  ------------------
  |  Branch (257:7): [True: 1.74k, False: 0]
  ------------------
  258|  1.74k|    iv_free(mrb, mrb->globals);
  259|  1.74k|}
mrb_gc_mark_iv:
  263|  2.89M|{
  264|  2.89M|  mark_tbl(mrb, obj->iv);
  265|  2.89M|}
mrb_gc_mark_iv_size:
  269|  2.89M|{
  270|  2.89M|  return iv_size(mrb, obj->iv);
  271|  2.89M|}
mrb_gc_free_iv:
  275|   440k|{
  276|   440k|  if (obj->iv) {
  ------------------
  |  Branch (276:7): [True: 329k, False: 110k]
  ------------------
  277|   329k|    iv_free(mrb, obj->iv);
  278|   329k|  }
  279|   440k|}
mrb_obj_iv_get:
  311|   301k|{
  312|   301k|  mrb_value v;
  313|       |
  314|   301k|  if (obj->iv && iv_get(mrb, obj->iv, sym, &v))
  ------------------
  |  Branch (314:7): [True: 289k, False: 12.0k]
  |  Branch (314:18): [True: 289k, False: 0]
  ------------------
  315|   289k|    return v;
  316|  12.0k|  return mrb_nil_value();
  317|   301k|}
mrb_iv_get:
  321|   128k|{
  322|   128k|  if (obj_iv_p(obj)) {
  ------------------
  |  Branch (322:7): [True: 128k, False: 0]
  ------------------
  323|   128k|    return mrb_obj_iv_get(mrb, mrb_obj_ptr(obj), sym);
  ------------------
  |  |   34|   128k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   128k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  324|   128k|  }
  325|      0|  return mrb_nil_value();
  326|   128k|}
mrb_obj_iv_set_force:
  362|  1.06M|{
  363|  1.06M|  assign_class_name(mrb, obj, sym, v);
  364|  1.06M|  if (!obj->iv) {
  ------------------
  |  Branch (364:7): [True: 329k, False: 732k]
  ------------------
  365|   329k|    obj->iv = iv_new(mrb);
  366|   329k|  }
  367|  1.06M|  iv_put(mrb, obj->iv, sym, v);
  368|  1.06M|  mrb_field_write_barrier_value(mrb, (struct RBasic*)obj, v);
  ------------------
  |  | 1317|  1.06M|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|  1.06M|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|  1.06M|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  2.12M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 515k, False: 546k]
  |  |  |  |  |  Branch (148:63): [True: 111k, False: 434k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|   434k|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|   434k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|  1.06M|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  369|  1.06M|}
mrb_obj_iv_set:
  373|   915k|{
  374|   915k|  mrb_check_frozen(mrb, obj);
  375|   915k|  mrb_obj_iv_set_force(mrb, obj, sym, v);
  376|   915k|}
mrb_iv_set:
  388|   245k|{
  389|   245k|  if (obj_iv_p(obj)) {
  ------------------
  |  Branch (389:7): [True: 245k, False: 0]
  ------------------
  390|   245k|    mrb_obj_iv_set(mrb, mrb_obj_ptr(obj), sym, v);
  ------------------
  |  |   34|   245k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   245k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  391|   245k|  }
  392|      0|  else {
  393|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot set instance variable");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  394|      0|  }
  395|   245k|}
mrb_obj_iv_defined:
  399|   157k|{
  400|   157k|  iv_tbl *t;
  401|       |
  402|   157k|  t = obj->iv;
  403|   157k|  if (t && iv_get(mrb, t, sym, NULL)) return TRUE;
  ------------------
  |  |   54|  13.9k|#  define TRUE 1
  ------------------
  |  Branch (403:7): [True: 17.4k, False: 139k]
  |  Branch (403:12): [True: 13.9k, False: 3.49k]
  ------------------
  404|   143k|  return FALSE;
  ------------------
  |  |   51|   143k|#  define FALSE 0
  ------------------
  405|   157k|}
mrb_iv_name_sym_p:
  416|  43.6k|{
  417|  43.6k|  const char *s;
  418|  43.6k|  mrb_int len;
  419|       |
  420|  43.6k|  s = mrb_sym_name_len(mrb, iv_name, &len);
  421|  43.6k|  if (len < 2) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (421:7): [True: 0, False: 43.6k]
  ------------------
  422|  43.6k|  if (s[0] != '@') return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (422:7): [True: 0, False: 43.6k]
  ------------------
  423|  43.6k|  if (ISDIGIT(s[1])) return FALSE;
  ------------------
  |  | 1342|  43.6k|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  ------------------
  |  |  |  Branch (1342:20): [True: 0, False: 43.6k]
  |  |  ------------------
  ------------------
                if (ISDIGIT(s[1])) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  424|  43.6k|  return mrb_ident_p(s+1, len-1);
  425|  43.6k|}
mrb_iv_name_sym_check:
  429|  43.6k|{
  430|  43.6k|  if (!mrb_iv_name_sym_p(mrb, iv_name)) {
  ------------------
  |  Branch (430:7): [True: 0, False: 43.6k]
  ------------------
  431|      0|    mrb_name_error(mrb, iv_name, "'%n' is not allowed as an instance variable name", iv_name);
  432|      0|  }
  433|  43.6k|}
mrb_mod_cv_get:
  614|  1.74k|{
  615|  1.74k|  struct RClass * cls = c;
  616|  1.74k|  mrb_value v;
  617|  1.74k|  int given = FALSE;
  ------------------
  |  |   51|  1.74k|#  define FALSE 0
  ------------------
  618|       |
  619|  8.72k|  while (c) {
  ------------------
  |  Branch (619:10): [True: 6.98k, False: 1.74k]
  ------------------
  620|  6.98k|    if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
  ------------------
  |  Branch (620:9): [True: 6.98k, False: 0]
  |  Branch (620:18): [True: 1.74k, False: 5.23k]
  ------------------
  621|  1.74k|      given = TRUE;
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
  622|  1.74k|    }
  623|  6.98k|    c = c->super;
  624|  6.98k|  }
  625|  1.74k|  if (given) return v;
  ------------------
  |  Branch (625:7): [True: 1.74k, False: 0]
  ------------------
  626|      0|  if (cls && cls->tt == MRB_TT_SCLASS) {
  ------------------
  |  Branch (626:7): [True: 0, False: 0]
  |  Branch (626:14): [True: 0, False: 0]
  ------------------
  627|      0|    mrb_value klass;
  628|       |
  629|      0|    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  630|      0|    c = mrb_class_ptr(klass);
  ------------------
  |  |   24|      0|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  631|      0|    if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
  ------------------
  |  Branch (631:9): [True: 0, False: 0]
  |  Branch (631:34): [True: 0, False: 0]
  ------------------
  632|      0|      given = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  633|      0|      while (c) {
  ------------------
  |  Branch (633:14): [True: 0, False: 0]
  ------------------
  634|      0|        if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
  ------------------
  |  Branch (634:13): [True: 0, False: 0]
  |  Branch (634:22): [True: 0, False: 0]
  ------------------
  635|      0|          given = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  636|      0|        }
  637|      0|        c = c->super;
  638|      0|      }
  639|      0|      if (given) return v;
  ------------------
  |  Branch (639:11): [True: 0, False: 0]
  ------------------
  640|      0|    }
  641|      0|  }
  642|      0|  mrb_name_error(mrb, sym, "uninitialized class variable %n in %C", sym, cls);
  643|       |  /* not reached */
  644|      0|  return mrb_nil_value();
  645|      0|}
mrb_mod_cv_set:
  655|  3.49k|{
  656|  3.49k|  struct RClass * cls = c;
  657|       |
  658|  20.9k|  while (c) {
  ------------------
  |  Branch (658:10): [True: 17.4k, False: 3.49k]
  ------------------
  659|  17.4k|    iv_tbl *t = c->iv;
  660|  17.4k|    int pos = iv_get(mrb, t, sym, NULL);
  661|       |
  662|  17.4k|    if (pos) {
  ------------------
  |  Branch (662:9): [True: 0, False: 17.4k]
  ------------------
  663|      0|      mrb_check_frozen(mrb, c);
  664|      0|      t->ptr[pos-1] = v;        /* iv_get returns pos+1 to put */
  665|      0|      mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
  ------------------
  |  | 1317|      0|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|      0|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|      0|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  666|      0|      return;
  667|      0|    }
  668|  17.4k|    c = c->super;
  669|  17.4k|  }
  670|       |
  671|  3.49k|  if (cls && cls->tt == MRB_TT_SCLASS) {
  ------------------
  |  Branch (671:7): [True: 3.49k, False: 0]
  |  Branch (671:14): [True: 0, False: 3.49k]
  ------------------
  672|      0|    mrb_value klass;
  673|       |
  674|      0|    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  675|      0|    switch (mrb_type(klass)) {
  676|      0|    case MRB_TT_CLASS:
  ------------------
  |  Branch (676:5): [True: 0, False: 0]
  ------------------
  677|      0|    case MRB_TT_MODULE:
  ------------------
  |  Branch (677:5): [True: 0, False: 0]
  ------------------
  678|      0|    case MRB_TT_SCLASS:
  ------------------
  |  Branch (678:5): [True: 0, False: 0]
  ------------------
  679|      0|      c = mrb_class_ptr(klass);
  ------------------
  |  |   24|      0|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  680|      0|      break;
  681|      0|    default:
  ------------------
  |  Branch (681:5): [True: 0, False: 0]
  ------------------
  682|      0|      c = cls;
  683|      0|      break;
  684|      0|    }
  685|      0|  }
  686|  3.49k|  else{
  687|  3.49k|    c = cls;
  688|  3.49k|  }
  689|       |
  690|  3.49k|  mrb_check_frozen(mrb, c);
  691|  3.49k|  if (!c->iv) {
  ------------------
  |  Branch (691:7): [True: 0, False: 3.49k]
  ------------------
  692|      0|    c->iv = iv_new(mrb);
  693|      0|  }
  694|       |
  695|  3.49k|  iv_put(mrb, c->iv, sym, v);
  696|  3.49k|  mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
  ------------------
  |  | 1317|  3.49k|#define mrb_field_write_barrier_value(mrb, obj, val) do{\
  |  | 1318|  3.49k|  if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|  3.49k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  6.98k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 1.74k, False: 1.74k]
  |  |  |  |  |  Branch (148:63): [True: 1.74k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|      0|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|  3.49k|} while (0)
  |  |  ------------------
  |  |  |  Branch (1319:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  697|  3.49k|}
mrb_vm_cv_set:
  740|  1.74k|{
  741|  1.74k|  struct RClass *c;
  742|  1.74k|  const struct RProc *p = mrb->c->ci->proc;
  743|       |
  744|  1.74k|  for (;;) {
  745|  1.74k|    c = MRB_PROC_TARGET_CLASS(p);
  ------------------
  |  |   74|  1.74k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|  1.74k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  1.74k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 1.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  746|  1.74k|    if (c && c->tt != MRB_TT_SCLASS) break;
  ------------------
  |  Branch (746:9): [True: 1.74k, False: 0]
  |  Branch (746:14): [True: 1.74k, False: 0]
  ------------------
  747|      0|    p = p->upper;
  748|      0|  }
  749|  1.74k|  mrb_mod_cv_set(mrb, c, sym, v);
  750|  1.74k|}
mrb_const_get:
  795|   134k|{
  796|   134k|  mod_const_check(mrb, mod);
  797|   134k|  return const_get(mrb, mrb_class_ptr(mod), sym, FALSE);
  ------------------
  |  |   24|   134k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   134k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
                return const_get(mrb, mrb_class_ptr(mod), sym, FALSE);
  ------------------
  |  |   51|   134k|#  define FALSE 0
  ------------------
  798|   134k|}
mrb_vm_const_get:
  802|   233k|{
  803|   233k|  struct RClass *c;
  804|   233k|  struct RClass *c2;
  805|   233k|  mrb_value v;
  806|   233k|  const struct RProc *proc = mrb->c->ci->proc;
  807|       |
  808|   233k|  c = MRB_PROC_TARGET_CLASS(proc);
  ------------------
  |  |   74|   233k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|   233k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   233k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 24.8k, False: 208k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  809|   233k|  if (!c) c = mrb->object_class;
  ------------------
  |  Branch (809:7): [True: 61.0k, False: 172k]
  ------------------
  810|   233k|  if (iv_get(mrb, c->iv, sym, &v)) {
  ------------------
  |  Branch (810:7): [True: 94.9k, False: 138k]
  ------------------
  811|  94.9k|    return v;
  812|  94.9k|  }
  813|   138k|  c2 = c;
  814|   138k|  while (c2 && c2->tt == MRB_TT_SCLASS) {
  ------------------
  |  Branch (814:10): [True: 138k, False: 0]
  |  Branch (814:16): [True: 0, False: 138k]
  ------------------
  815|      0|    mrb_value klass;
  816|       |
  817|      0|    if (!iv_get(mrb, c2->iv, MRB_SYM(__attached__), &klass)) {
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  |  Branch (817:9): [True: 0, False: 0]
  ------------------
  818|      0|      c2 = NULL;
  819|      0|      break;
  820|      0|    }
  821|      0|    c2 = mrb_class_ptr(klass);
  ------------------
  |  |   24|      0|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  822|      0|  }
  823|   138k|  if (c2 && (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE)) c = c2;
  ------------------
  |  Branch (823:7): [True: 138k, False: 0]
  |  Branch (823:14): [True: 106k, False: 31.8k]
  |  Branch (823:40): [True: 31.8k, False: 0]
  ------------------
  824|   138k|  proc = proc->upper;
  825|   274k|  while (proc) {
  ------------------
  |  Branch (825:10): [True: 245k, False: 28.3k]
  ------------------
  826|   245k|    c2 = MRB_PROC_TARGET_CLASS(proc);
  ------------------
  |  |   74|   245k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|   245k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   245k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 245k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  827|   245k|    if (!c2) c2 = mrb->object_class;
  ------------------
  |  Branch (827:9): [True: 138k, False: 107k]
  ------------------
  828|   245k|    if (c2 && iv_get(mrb, c2->iv, sym, &v)) {
  ------------------
  |  Branch (828:9): [True: 245k, False: 0]
  |  Branch (828:15): [True: 110k, False: 135k]
  ------------------
  829|   110k|      return v;
  830|   110k|    }
  831|   135k|    proc = proc->upper;
  832|   135k|  }
  833|  28.3k|  return const_get(mrb, c, sym, TRUE);
  ------------------
  |  |   54|  28.3k|#  define TRUE 1
  ------------------
  834|   138k|}
mrb_const_set:
  838|  1.74k|{
  839|  1.74k|  mod_const_check(mrb, mod);
  840|  1.74k|  if (mrb_type(v) == MRB_TT_CLASS || mrb_type(v) == MRB_TT_MODULE) {
  ------------------
  |  Branch (840:7): [True: 1.74k, False: 0]
  |  Branch (840:38): [True: 0, False: 0]
  ------------------
  841|  1.74k|    mrb_class_name_class(mrb, mrb_class_ptr(mod), mrb_class_ptr(v), sym);
  ------------------
  |  |   24|  1.74k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  1.74k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
                  mrb_class_name_class(mrb, mrb_class_ptr(mod), mrb_class_ptr(v), sym);
  ------------------
  |  |   24|  1.74k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  1.74k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  842|  1.74k|  }
  843|  1.74k|  mrb_iv_set(mrb, mod, sym, v);
  844|  1.74k|}
mrb_vm_const_set:
  848|  15.7k|{
  849|  15.7k|  struct RClass *c;
  850|       |
  851|  15.7k|  c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
  ------------------
  |  |   74|  15.7k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|  15.7k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  15.7k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 15.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  852|  15.7k|  if (!c) c = mrb->object_class;
  ------------------
  |  Branch (852:7): [True: 5.23k, False: 10.4k]
  ------------------
  853|  15.7k|  mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
  854|  15.7k|}
mrb_define_const_id:
  865|  85.5k|{
  866|  85.5k|  mrb_obj_iv_set(mrb, (struct RObject*)mod, name, v);
  867|  85.5k|}
mrb_define_const:
  871|   263k|{
  872|   263k|  mrb_obj_iv_set(mrb, (struct RObject*)mod, mrb_intern_cstr(mrb, name), v);
  873|   263k|}
mrb_define_global_const:
  877|  13.9k|{
  878|  13.9k|  mrb_define_const(mrb, mrb->object_class, name, val);
  879|  13.9k|}
mrb_gv_set:
  941|  5.23k|{
  942|  5.23k|  iv_tbl *t;
  943|       |
  944|  5.23k|  if (!mrb->globals) {
  ------------------
  |  Branch (944:7): [True: 1.74k, False: 3.49k]
  ------------------
  945|  1.74k|    mrb->globals = iv_new(mrb);
  946|  1.74k|  }
  947|  5.23k|  t = mrb->globals;
  948|  5.23k|  iv_put(mrb, t, sym, v);
  949|  5.23k|}
mrb_const_defined:
 1013|  1.74k|{
 1014|  1.74k|  return const_defined_0(mrb, mod, id, TRUE, TRUE);
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
                return const_defined_0(mrb, mod, id, TRUE, TRUE);
  ------------------
  |  |   54|  1.74k|#  define TRUE 1
  ------------------
 1015|  1.74k|}
mrb_const_defined_at:
 1019|   286k|{
 1020|   286k|  return const_defined_0(mrb, mod, id, TRUE, FALSE);
  ------------------
  |  |   54|   286k|#  define TRUE 1
  ------------------
                return const_defined_0(mrb, mod, id, TRUE, FALSE);
  ------------------
  |  |   51|   286k|#  define FALSE 0
  ------------------
 1021|   286k|}
mrb_ident_p:
 1135|  45.3k|{
 1136|  45.3k|  mrb_int i;
 1137|       |
 1138|   317k|  for (i = 0; i < len; i++) {
  ------------------
  |  Branch (1138:15): [True: 272k, False: 45.3k]
  ------------------
 1139|   272k|    if (!identchar(s[i])) return FALSE;
  ------------------
  |  | 1131|   272k|#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1344|   544k|#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1341|   544k|#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1341:20): [True: 261k, False: 10.4k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1342|  10.4k|#define ISDIGIT(c) (((unsigned)(c) - '0') < 10)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1342:20): [True: 0, False: 10.4k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
  |  |  ------------------
  |  |  |  | 1336|      0|#define ISASCII(c) ((unsigned)(c) <= 0x7f)
  |  |  ------------------
  |  |  |  Branch (1131:37): [True: 10.4k, False: 0]
  |  |  |  Branch (1131:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (!identchar(s[i])) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 1140|   272k|  }
 1141|  45.3k|  return TRUE;
  ------------------
  |  |   54|  45.3k|#  define TRUE 1
  ------------------
 1142|  45.3k|}
variable.c:mark_tbl:
  244|  2.93M|{
  245|  2.93M|  iv_foreach(mrb, t, iv_mark_i, 0);
  246|  2.93M|}
variable.c:iv_mark_i:
  237|  7.61M|{
  238|  7.61M|  mrb_gc_mark_value(mrb, v);
  ------------------
  |  | 1313|  7.61M|#define mrb_gc_mark_value(mrb,val) do {\
  |  | 1314|  7.61M|  if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |  148|  7.61M|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  15.2M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (148:29): [True: 4.25M, False: 3.35M]
  |  |  |  |  |  Branch (148:63): [True: 34.6k, False: 3.31M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
  |  |  ------------------
  |  |  |  |   22|  3.31M|#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  3.31M|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1315|  7.61M|} while (0)
  |  |  ------------------
  |  |  |  Branch (1315:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  239|  7.61M|  return 0;
  240|  7.61M|}
variable.c:iv_free:
  230|   331k|{
  231|   331k|  mrb_free(mrb, t->ptr);
  232|   331k|  mrb_free(mrb, t);
  233|   331k|}
variable.c:iv_size:
  200|  2.89M|{
  201|  2.89M|  if (t == NULL) return 0;
  ------------------
  |  Branch (201:7): [True: 93.2k, False: 2.80M]
  ------------------
  202|  2.80M|  return (size_t)t->size;
  203|  2.89M|}
variable.c:iv_get:
  115|  1.58M|{
  116|  1.58M|  int hash, pos, start;
  117|       |
  118|  1.58M|  if (t == NULL) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (118:7): [True: 0, False: 1.58M]
  ------------------
  119|  1.58M|  if (t->alloc == 0) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (119:7): [True: 0, False: 1.58M]
  ------------------
  120|  1.58M|  if (t->size == 0) return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (120:7): [True: 0, False: 1.58M]
  ------------------
  121|       |
  122|  1.58M|  mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
  123|  1.58M|  mrb_value *vals = t->ptr;
  124|  1.58M|  hash = kh_int_hash_func(mrb, sym);
  ------------------
  |  |  267|  1.58M|#define kh_int_hash_func(mrb,key) (khint_t)((key)^((key)<<2)^((key)>>2))
  ------------------
  125|  1.58M|  start = pos = hash & (t->alloc-1);
  126|  3.43M|  for (;;) {
  127|  3.43M|    mrb_sym key = keys[pos];
  128|  3.43M|    if (key == sym) {
  ------------------
  |  Branch (128:9): [True: 777k, False: 2.65M]
  ------------------
  129|   777k|      if (vp) *vp = vals[pos];
  ------------------
  |  Branch (129:11): [True: 658k, False: 118k]
  ------------------
  130|   777k|      return pos+1;
  131|   777k|    }
  132|  2.65M|    else if (key == IV_EMPTY) {
  ------------------
  |  |   22|  2.65M|#define IV_EMPTY 0
  ------------------
  |  Branch (132:14): [True: 746k, False: 1.90M]
  ------------------
  133|   746k|      return 0;
  134|   746k|    }
  135|  1.90M|    pos = (pos+1) & (t->alloc-1);
  136|  1.90M|    if (pos == start) {         /* not found */
  ------------------
  |  Branch (136:9): [True: 60.2k, False: 1.84M]
  ------------------
  137|  60.2k|      return 0;
  138|  60.2k|    }
  139|  1.90M|  }
  140|  1.58M|}
variable.c:obj_iv_p:
  294|   373k|{
  295|   373k|  switch (mrb_type(obj)) {
  296|   261k|    case MRB_TT_OBJECT:
  ------------------
  |  Branch (296:5): [True: 261k, False: 111k]
  ------------------
  297|   265k|    case MRB_TT_CLASS:
  ------------------
  |  Branch (297:5): [True: 3.49k, False: 370k]
  ------------------
  298|   265k|    case MRB_TT_MODULE:
  ------------------
  |  Branch (298:5): [True: 0, False: 373k]
  ------------------
  299|   373k|    case MRB_TT_SCLASS:
  ------------------
  |  Branch (299:5): [True: 108k, False: 265k]
  ------------------
  300|   373k|    case MRB_TT_HASH:
  ------------------
  |  Branch (300:5): [True: 0, False: 373k]
  ------------------
  301|   373k|    case MRB_TT_CDATA:
  ------------------
  |  Branch (301:5): [True: 0, False: 373k]
  ------------------
  302|   373k|    case MRB_TT_EXCEPTION:
  ------------------
  |  Branch (302:5): [True: 252, False: 373k]
  ------------------
  303|   373k|      return TRUE;
  ------------------
  |  |   54|   373k|#  define TRUE 1
  ------------------
  304|      0|    default:
  ------------------
  |  Branch (304:5): [True: 0, False: 373k]
  ------------------
  305|      0|      return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  306|   373k|  }
  307|   373k|}
variable.c:assign_class_name:
  336|  1.06M|{
  337|  1.06M|  if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) {
  ------------------
  |  Branch (337:7): [True: 663k, False: 398k]
  |  Branch (337:31): [True: 158k, False: 504k]
  ------------------
  338|   158k|    struct RObject *c = mrb_obj_ptr(v);
  ------------------
  |  |   34|   158k|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   158k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  339|   158k|    if (obj != c && ISUPPER(mrb_sym_name_len(mrb, sym, NULL)[0])) {
  ------------------
  |  | 1339|   155k|#define ISUPPER(c) (((unsigned)(c) - 'A') < 26)
  |  |  ------------------
  |  |  |  Branch (1339:20): [True: 153k, False: 1.74k]
  |  |  ------------------
  ------------------
  |  Branch (339:9): [True: 155k, False: 3.49k]
  ------------------
  340|   153k|      mrb_sym id_classname = MRB_SYM(__classname__);
  ------------------
  |  |   18|   153k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  341|   153k|      mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
  342|       |
  343|   153k|      if (mrb_nil_p(o)) {
  ------------------
  |  |  174|   153k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 3.49k, False: 150k]
  |  |  ------------------
  ------------------
  344|  3.49k|        mrb_sym id_outer = MRB_SYM(__outer__);
  ------------------
  |  |   18|  3.49k|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  345|  3.49k|        o = mrb_obj_iv_get(mrb, c, id_outer);
  346|       |
  347|  3.49k|        if (mrb_nil_p(o)) {
  ------------------
  |  |  174|  3.49k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 3.49k, False: 0]
  |  |  ------------------
  ------------------
  348|  3.49k|          if ((struct RClass*)obj == mrb->object_class) {
  ------------------
  |  Branch (348:15): [True: 3.49k, False: 0]
  ------------------
  349|  3.49k|            mrb_obj_iv_set_force(mrb, c, id_classname, mrb_symbol_value(sym));
  350|  3.49k|          }
  351|      0|          else {
  352|      0|            mrb_obj_iv_set_force(mrb, c, id_outer, mrb_obj_value(obj));
  353|      0|          }
  354|  3.49k|        }
  355|  3.49k|      }
  356|   153k|    }
  357|   158k|  }
  358|  1.06M|}
variable.c:namespace_p:
  330|  1.72M|{
  331|  1.72M|  return tt == MRB_TT_CLASS || tt == MRB_TT_MODULE ? TRUE : FALSE;
  ------------------
  |  |   54|   821k|#  define TRUE 1
  ------------------
                return tt == MRB_TT_CLASS || tt == MRB_TT_MODULE ? TRUE : FALSE;
  ------------------
  |  |   51|  2.62M|#  define FALSE 0
  ------------------
  |  Branch (331:10): [True: 465k, False: 1.25M]
  |  Branch (331:32): [True: 355k, False: 903k]
  ------------------
  332|  1.72M|}
variable.c:iv_new:
   29|   331k|{
   30|   331k|  iv_tbl *t;
   31|       |
   32|   331k|  t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
   33|   331k|  t->size = 0;
   34|   331k|  t->alloc = 0;
   35|   331k|  t->ptr = NULL;
   36|       |
   37|   331k|  return t;
   38|   331k|}
variable.c:iv_put:
   69|  2.09M|{
   70|  2.09M|  int hash, pos, start, dpos = -1;
   71|       |
   72|  2.09M|  if (t->alloc == 0) {
  ------------------
  |  Branch (72:7): [True: 331k, False: 1.76M]
  ------------------
   73|   331k|    iv_rehash(mrb, t);
   74|   331k|  }
   75|       |
   76|  2.09M|  mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
   77|  2.09M|  mrb_value *vals = t->ptr;
   78|  2.09M|  hash = kh_int_hash_func(mrb, sym);
  ------------------
  |  |  267|  2.09M|#define kh_int_hash_func(mrb,key) (khint_t)((key)^((key)<<2)^((key)>>2))
  ------------------
   79|  2.09M|  start = pos = hash & (t->alloc-1);
   80|  8.46M|  for (;;) {
   81|  8.46M|    mrb_sym key = keys[pos];
   82|  8.46M|    if (key == sym) {
  ------------------
  |  Branch (82:9): [True: 25.1k, False: 8.43M]
  ------------------
   83|  25.1k|      vals[pos] = val;
   84|  25.1k|      return;
   85|  25.1k|    }
   86|  8.43M|    else if (key == IV_EMPTY) {
  ------------------
  |  |   22|  8.43M|#define IV_EMPTY 0
  ------------------
  |  Branch (86:14): [True: 2.06M, False: 6.36M]
  ------------------
   87|  2.06M|      t->size++;
   88|  2.06M|      keys[pos] = sym;
   89|  2.06M|      vals[pos] = val;
   90|  2.06M|      return;
   91|  2.06M|    }
   92|  6.36M|    else if (key == IV_DELETED && dpos < 0) {
  ------------------
  |  |   23|  12.7M|#define IV_DELETED (1UL<<31)
  ------------------
  |  Branch (92:14): [True: 0, False: 6.36M]
  |  Branch (92:35): [True: 0, False: 0]
  ------------------
   93|      0|      dpos = pos;
   94|      0|    }
   95|  6.36M|    pos = (pos+1) & (t->alloc-1);
   96|  6.36M|    if (pos == start) {         /* not found */
  ------------------
  |  Branch (96:9): [True: 77.6k, False: 6.29M]
  ------------------
   97|  77.6k|      if (dpos >= 0) {
  ------------------
  |  Branch (97:11): [True: 0, False: 77.6k]
  ------------------
   98|      0|        t->size++;
   99|      0|        keys[dpos] = sym;
  100|      0|        vals[dpos] = val;
  101|      0|        return;
  102|      0|      }
  103|       |      /* no room */
  104|  77.6k|      iv_rehash(mrb, t);
  105|  77.6k|      keys = (mrb_sym*)&t->ptr[t->alloc];
  106|  77.6k|      vals = t->ptr;
  107|  77.6k|      start = pos = hash & (t->alloc-1);
  108|  77.6k|    }
  109|  6.36M|  }
  110|  2.09M|}
variable.c:iv_rehash:
   44|   409k|{
   45|   409k|  int old_alloc = t->alloc;
   46|   409k|  int new_alloc = old_alloc+4;
   47|   409k|  mrb_value *old_ptr = t->ptr;
   48|       |
   49|   409k|  khash_power2(new_alloc);
  ------------------
  |  |   41|   409k|#define khash_power2(v) do { \
  |  |   42|   409k|  v--;\
  |  |   43|   409k|  v |= v >> 1;\
  |  |   44|   409k|  v |= v >> 2;\
  |  |   45|   409k|  v |= v >> 4;\
  |  |   46|   409k|  v |= v >> 8;\
  |  |   47|   409k|  v |= v >> 16;\
  |  |   48|   409k|  v++;\
  |  |   49|   409k|} while (0)
  |  |  ------------------
  |  |  |  Branch (49:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   50|       |
   51|   409k|  t->ptr = (mrb_value*)mrb_calloc(mrb, sizeof(mrb_value)+sizeof(mrb_sym), new_alloc);
   52|   409k|  t->size = 0;
   53|   409k|  t->alloc = new_alloc;
   54|   409k|  if (old_alloc == 0) return;
  ------------------
  |  Branch (54:7): [True: 331k, False: 77.6k]
  ------------------
   55|       |
   56|  77.6k|  mrb_sym *keys = (mrb_sym*)&old_ptr[old_alloc];
   57|  77.6k|  mrb_value *vals = old_ptr;
   58|  1.10M|  for (int i = 0; i < old_alloc; i++) {
  ------------------
  |  Branch (58:19): [True: 1.02M, False: 77.6k]
  ------------------
   59|  1.02M|    if (IV_KEY_P(keys[i])) {
  ------------------
  |  |   24|  1.02M|#define IV_KEY_P(k) (((k)&~((uint32_t)IV_DELETED))!=0)
  |  |  ------------------
  |  |  |  |   23|  1.02M|#define IV_DELETED (1UL<<31)
  |  |  ------------------
  |  |  |  Branch (24:21): [True: 1.02M, False: 0]
  |  |  ------------------
  ------------------
   60|  1.02M|      iv_put(mrb, t, keys[i], vals[i]);
   61|  1.02M|    }
   62|  1.02M|  }
   63|  77.6k|  mrb_free(mrb, old_ptr);
   64|  77.6k|}
variable.c:iv_foreach:
  177|  2.93M|{
  178|  2.93M|  int i;
  179|       |
  180|  2.93M|  if (t == NULL) return;
  ------------------
  |  Branch (180:7): [True: 96.7k, False: 2.83M]
  ------------------
  181|  2.83M|  if (t->alloc == 0) return;
  ------------------
  |  Branch (181:7): [True: 0, False: 2.83M]
  ------------------
  182|  2.83M|  if (t->size == 0) return;
  ------------------
  |  Branch (182:7): [True: 0, False: 2.83M]
  ------------------
  183|       |
  184|  2.83M|  mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
  185|  2.83M|  mrb_value *vals = t->ptr;
  186|  20.8M|  for (i=0; i<t->alloc; i++) {
  ------------------
  |  Branch (186:13): [True: 18.0M, False: 2.83M]
  ------------------
  187|  18.0M|    if (IV_KEY_P(keys[i])) {
  ------------------
  |  |   24|  18.0M|#define IV_KEY_P(k) (((k)&~((uint32_t)IV_DELETED))!=0)
  |  |  ------------------
  |  |  |  |   23|  18.0M|#define IV_DELETED (1UL<<31)
  |  |  ------------------
  |  |  |  Branch (24:21): [True: 7.61M, False: 10.4M]
  |  |  ------------------
  ------------------
  188|  7.61M|      if ((*func)(mrb, keys[i], vals[i], p) != 0) {
  ------------------
  |  Branch (188:11): [True: 0, False: 7.61M]
  ------------------
  189|      0|        return;
  190|      0|      }
  191|  7.61M|    }
  192|  18.0M|  }
  193|  2.83M|  return;
  194|  2.83M|}
variable.c:mod_const_check:
  754|   135k|{
  755|   135k|  switch (mrb_type(mod)) {
  756|   133k|  case MRB_TT_CLASS:
  ------------------
  |  Branch (756:3): [True: 133k, False: 2.65k]
  ------------------
  757|   135k|  case MRB_TT_MODULE:
  ------------------
  |  Branch (757:3): [True: 2.65k, False: 133k]
  ------------------
  758|   135k|  case MRB_TT_SCLASS:
  ------------------
  |  Branch (758:3): [True: 0, False: 135k]
  ------------------
  759|   135k|    break;
  760|      0|  default:
  ------------------
  |  Branch (760:3): [True: 0, False: 135k]
  ------------------
  761|      0|    mrb_raise(mrb, E_TYPE_ERROR, "constant look-up for non class/module");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  762|      0|    break;
  763|   135k|  }
  764|   135k|}
variable.c:const_get:
  768|   162k|{
  769|   162k|  struct RClass *c = base;
  770|   162k|  mrb_value v;
  771|   162k|  mrb_bool retry = FALSE;
  ------------------
  |  |   51|   162k|#  define FALSE 0
  ------------------
  772|   162k|  mrb_value name;
  773|       |
  774|       |  /* if skip then skip the current class (already searched) */
  775|   162k|  if (skip) c = c->super;
  ------------------
  |  Branch (775:7): [True: 28.3k, False: 134k]
  ------------------
  776|   162k|L_RETRY:
  777|   172k|  while (c) {
  ------------------
  |  Branch (777:10): [True: 172k, False: 0]
  ------------------
  778|   172k|    if (!MRB_FLAG_TEST(c, MRB_FL_CLASS_IS_PREPENDED) && c->iv && iv_get(mrb, c->iv, sym, &v)) {
  ------------------
  |  |   17|   345k|#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & (flag))
  ------------------
  |  Branch (778:9): [True: 172k, False: 0]
  |  Branch (778:57): [True: 172k, False: 0]
  |  Branch (778:66): [True: 162k, False: 10.4k]
  ------------------
  779|   162k|      return v;
  780|   162k|    }
  781|  10.4k|    c = c->super;
  782|  10.4k|    if (!skip && c == mrb->object_class) break;
  ------------------
  |  Branch (782:9): [True: 10.4k, False: 0]
  |  Branch (782:18): [True: 0, False: 10.4k]
  ------------------
  783|  10.4k|  }
  784|      0|  if (!retry && base->tt == MRB_TT_MODULE && skip) {
  ------------------
  |  Branch (784:7): [True: 0, False: 0]
  |  Branch (784:17): [True: 0, False: 0]
  |  Branch (784:46): [True: 0, False: 0]
  ------------------
  785|      0|    c = mrb->object_class;
  786|      0|    retry = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  787|      0|    goto L_RETRY;
  788|      0|  }
  789|      0|  name = mrb_symbol_value(sym);
  790|      0|  return mrb_funcall_argv(mrb, mrb_obj_value(base), MRB_SYM(const_missing), 1, &name);
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  791|      0|}
variable.c:const_defined_0:
  989|   287k|{
  990|   287k|  struct RClass *klass = mrb_class_ptr(mod);
  ------------------
  |  |   24|   287k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   287k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  991|   287k|  struct RClass *tmp;
  992|   287k|  mrb_bool mod_retry = FALSE;
  ------------------
  |  |   51|   287k|#  define FALSE 0
  ------------------
  993|       |
  994|   287k|  tmp = klass;
  995|   287k|retry:
  996|   759k|  while (tmp) {
  ------------------
  |  Branch (996:10): [True: 600k, False: 158k]
  ------------------
  997|   600k|    if (iv_get(mrb, tmp->iv, id, NULL)) {
  ------------------
  |  Branch (997:9): [True: 104k, False: 495k]
  ------------------
  998|   104k|      return TRUE;
  ------------------
  |  |   54|   104k|#  define TRUE 1
  ------------------
  999|   104k|    }
 1000|   495k|    if (!recurse && (klass != mrb->object_class)) break;
  ------------------
  |  Branch (1000:9): [True: 495k, False: 0]
  |  Branch (1000:21): [True: 24.4k, False: 471k]
  ------------------
 1001|   471k|    tmp = tmp->super;
 1002|   471k|  }
 1003|   183k|  if (!exclude && !mod_retry && (klass->tt == MRB_TT_MODULE)) {
  ------------------
  |  Branch (1003:7): [True: 0, False: 183k]
  |  Branch (1003:19): [True: 0, False: 0]
  |  Branch (1003:33): [True: 0, False: 0]
  ------------------
 1004|      0|    mod_retry = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 1005|      0|    tmp = mrb->object_class;
 1006|      0|    goto retry;
 1007|      0|  }
 1008|   183k|  return FALSE;
  ------------------
  |  |   51|   183k|#  define FALSE 0
  ------------------
 1009|   183k|}

mrb_init_version:
    6|  1.74k|{
    7|  1.74k|  mrb_value mruby_version = mrb_str_new_lit(mrb, MRUBY_VERSION);
  ------------------
  |  | 1209|  1.74k|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
    8|       |
    9|  1.74k|  mrb_define_global_const(mrb, "RUBY_VERSION", mrb_str_new_lit(mrb, MRUBY_RUBY_VERSION));
  ------------------
  |  | 1209|  1.74k|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
   10|  1.74k|  mrb_define_global_const(mrb, "RUBY_ENGINE", mrb_str_new_lit(mrb, MRUBY_RUBY_ENGINE));
  ------------------
  |  | 1209|  1.74k|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
   11|  1.74k|  mrb_define_global_const(mrb, "RUBY_ENGINE_VERSION", mruby_version);
   12|  1.74k|  mrb_define_global_const(mrb, "MRUBY_VERSION", mruby_version);
   13|  1.74k|  mrb_define_global_const(mrb, "MRUBY_RELEASE_NO", mrb_fixnum_value(MRUBY_RELEASE_NO));
  ------------------
  |  |   78|  1.74k|#define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
  |  |  ------------------
  |  |  |  |   40|  1.74k|#define MRUBY_RELEASE_MAJOR 3
  |  |  ------------------
  |  |               #define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
  |  |  ------------------
  |  |  |  |   45|  1.74k|#define MRUBY_RELEASE_MINOR 2
  |  |  ------------------
  |  |               #define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
  |  |  ------------------
  |  |  |  |   50|  1.74k|#define MRUBY_RELEASE_TEENY 0
  |  |  ------------------
  ------------------
   14|  1.74k|  mrb_define_global_const(mrb, "MRUBY_RELEASE_DATE", mrb_str_new_lit(mrb, MRUBY_RELEASE_DATE));
  ------------------
  |  | 1209|  1.74k|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
   15|  1.74k|  mrb_define_global_const(mrb, "MRUBY_DESCRIPTION", mrb_str_new_lit(mrb, MRUBY_DESCRIPTION));
  ------------------
  |  | 1209|  1.74k|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
   16|  1.74k|  mrb_define_global_const(mrb, "MRUBY_COPYRIGHT", mrb_str_new_lit(mrb, MRUBY_COPYRIGHT));
  ------------------
  |  | 1209|  1.74k|#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
  |  |  ------------------
  |  |  |  | 1075|  1.74k|#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
  |  |  ------------------
  ------------------
   17|  1.74k|}

mrb_vm_ci_target_class:
  271|   118k|{
  272|   118k|  return CI_TARGET_CLASS(ci);
  ------------------
  |  |  267|   118k|#define CI_TARGET_CLASS(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env->c : (ci)->u.target_class)
  |  |  ------------------
  |  |  |  Branch (267:31): [True: 118k, False: 0]
  |  |  |  Branch (267:46): [True: 0, False: 118k]
  |  |  ------------------
  ------------------
  273|   118k|}
mrb_vm_ci_target_class_set:
  277|  1.54k|{
  278|  1.54k|  struct REnv *e = ci->u.env;
  279|  1.54k|  if (e && e->tt == MRB_TT_ENV) {
  ------------------
  |  Branch (279:7): [True: 1.54k, False: 0]
  |  Branch (279:12): [True: 0, False: 1.54k]
  ------------------
  280|      0|    e->c = tc;
  281|      0|  }
  282|  1.54k|  else {
  283|  1.54k|    ci->u.target_class = tc;
  284|  1.54k|  }
  285|  1.54k|}
mrb_vm_ci_env:
  291|  25.0k|{
  292|  25.0k|  return CI_ENV(ci);
  ------------------
  |  |  287|  25.0k|#define CI_ENV(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env : NULL)
  |  |  ------------------
  |  |  |  Branch (287:22): [True: 25.0k, False: 0]
  |  |  |  Branch (287:37): [True: 0, False: 25.0k]
  |  |  ------------------
  ------------------
  293|  25.0k|}
mrb_vm_ci_env_clear:
  326|  64.5k|{
  327|  64.5k|  struct REnv *e = ci->u.env;
  328|  64.5k|  if (e && e->tt == MRB_TT_ENV) {
  ------------------
  |  Branch (328:7): [True: 64.5k, False: 0]
  |  Branch (328:12): [True: 0, False: 64.5k]
  ------------------
  329|      0|    ci->u.target_class = e->c;
  330|      0|    mrb_env_unshare(mrb, e, FALSE);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  331|      0|  }
  332|  64.5k|}
mrb_env_unshare:
  373|  71.3k|{
  374|  71.3k|  if (e == NULL) return TRUE;
  ------------------
  |  |   54|  46.9k|#  define TRUE 1
  ------------------
  |  Branch (374:7): [True: 46.9k, False: 24.4k]
  ------------------
  375|  24.4k|  if (!MRB_ENV_ONSTACK_P(e)) return TRUE;
  ------------------
  |  |   30|  24.4k|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|  24.4k|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
                if (!MRB_ENV_ONSTACK_P(e)) return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (375:7): [True: 0, False: 24.4k]
  ------------------
  376|  24.4k|  if (e->cxt != mrb->c) return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (376:7): [True: 0, False: 24.4k]
  ------------------
  377|  24.4k|  if (e == CI_ENV(mrb->c->cibase)) return TRUE; /* for mirb */
  ------------------
  |  |  287|  24.4k|#define CI_ENV(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env : NULL)
  |  |  ------------------
  |  |  |  Branch (287:22): [True: 24.4k, False: 0]
  |  |  |  Branch (287:37): [True: 0, False: 24.4k]
  |  |  ------------------
  ------------------
                if (e == CI_ENV(mrb->c->cibase)) return TRUE; /* for mirb */
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (377:7): [True: 0, False: 24.4k]
  ------------------
  378|       |
  379|  24.4k|  size_t len = (size_t)MRB_ENV_LEN(e);
  ------------------
  |  |   27|  24.4k|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  380|  24.4k|  if (len == 0) {
  ------------------
  |  Branch (380:7): [True: 0, False: 24.4k]
  ------------------
  381|      0|    e->stack = NULL;
  382|      0|    MRB_ENV_CLOSE(e);
  ------------------
  |  |   29|      0|#define MRB_ENV_CLOSE(e) ((e)->flags |= MRB_ENV_CLOSED)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
  383|      0|    return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  384|      0|  }
  385|       |
  386|  24.4k|  size_t live = mrb->gc.live;
  387|  24.4k|  mrb_value *p = (mrb_value*)mrb_malloc_simple(mrb, sizeof(mrb_value)*len);
  388|  24.4k|  if (live != mrb->gc.live && mrb_object_dead_p(mrb, (struct RBasic*)e)) {
  ------------------
  |  Branch (388:7): [True: 0, False: 24.4k]
  |  Branch (388:31): [True: 0, False: 0]
  ------------------
  389|       |    // The e object is now subject to GC inside mrb_malloc_simple().
  390|       |    // Moreover, if NULL is returned due to mrb_malloc_simple() failure, simply ignore it.
  391|      0|    mrb_free(mrb, p);
  392|      0|    return TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  393|      0|  }
  394|  24.4k|  else if (p) {
  ------------------
  |  Branch (394:12): [True: 24.4k, False: 0]
  ------------------
  395|  24.4k|    stack_copy(p, e->stack, len);
  396|  24.4k|    e->stack = p;
  397|  24.4k|    MRB_ENV_CLOSE(e);
  ------------------
  |  |   29|  24.4k|#define MRB_ENV_CLOSE(e) ((e)->flags |= MRB_ENV_CLOSED)
  |  |  ------------------
  |  |  |  |   28|  24.4k|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
  398|  24.4k|    mrb_write_barrier(mrb, (struct RBasic*)e);
  399|  24.4k|    return TRUE;
  ------------------
  |  |   54|  24.4k|#  define TRUE 1
  ------------------
  400|  24.4k|  }
  401|      0|  else {
  402|      0|    e->stack = NULL;
  403|      0|    MRB_ENV_CLOSE(e);
  ------------------
  |  |   29|      0|#define MRB_ENV_CLOSE(e) ((e)->flags |= MRB_ENV_CLOSED)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
  404|      0|    MRB_ENV_SET_LEN(e, 0);
  ------------------
  |  |   26|      0|#define MRB_ENV_SET_LEN(e,len) ((e)->flags = (((e)->flags & ~0xff)|((unsigned int)(len) & 0xff)))
  ------------------
  405|      0|    MRB_ENV_SET_BIDX(e, 0);
  ------------------
  |  |   32|      0|#define MRB_ENV_SET_BIDX(e,idx) ((e)->flags = (((e)->flags & ~(0xff<<8))|((unsigned int)(idx) & 0xff)<<8))
  ------------------
  406|      0|    if (!noraise) {
  ------------------
  |  Branch (406:9): [True: 0, False: 0]
  ------------------
  407|      0|      mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
  408|      0|    }
  409|      0|    return FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  410|      0|  }
  411|  24.4k|}
mrb_protect_error:
  436|  1.74k|{
  437|  1.74k|  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
  438|  1.74k|  struct mrb_jmpbuf c_jmp;
  439|  1.74k|  mrb_value result = mrb_nil_value();
  440|  1.74k|  int ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  1.74k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  441|  1.74k|  const struct mrb_context *c = mrb->c;
  442|  1.74k|  ptrdiff_t ci_index = c->ci - c->cibase;
  443|       |
  444|  1.74k|  if (error) { *error = FALSE; }
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  |  Branch (444:7): [True: 0, False: 1.74k]
  ------------------
  445|       |
  446|  1.74k|  MRB_TRY(&c_jmp) {
  ------------------
  |  |   44|  1.74k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  1.74k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 1.74k, False: 0]
  |  |  ------------------
  ------------------
  447|  1.74k|    mrb->jmp = &c_jmp;
  448|  1.74k|    result = body(mrb, userdata);
  449|  1.74k|    mrb->jmp = prev_jmp;
  450|  1.74k|  }
  451|  1.74k|  MRB_CATCH(&c_jmp) {
  ------------------
  |  |   45|  1.74k|#define MRB_CATCH(buf) } else {
  ------------------
  452|      0|    mrb->jmp = prev_jmp;
  453|      0|    result = mrb_obj_value(mrb->exc);
  454|      0|    mrb->exc = NULL;
  455|      0|    if (error) { *error = TRUE; }
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
  |  Branch (455:9): [True: 0, False: 0]
  ------------------
  456|      0|    if (mrb->c == c) {
  ------------------
  |  Branch (456:9): [True: 0, False: 0]
  ------------------
  457|      0|      while (c->ci - c->cibase > ci_index) {
  ------------------
  |  Branch (457:14): [True: 0, False: 0]
  ------------------
  458|      0|        cipop(mrb);
  459|      0|      }
  460|      0|    }
  461|      0|    else {
  462|       |      // It was probably switched by mrb_fiber_resume().
  463|       |      // Simply destroy all successive CINFO_DIRECTs once the fiber has been switched.
  464|      0|      c = mrb->c;
  465|      0|      while (c->ci > c->cibase && c->ci->cci == CINFO_DIRECT) {
  ------------------
  |  |  336|      0|#define CINFO_DIRECT  2 // called method from C
  ------------------
  |  Branch (465:14): [True: 0, False: 0]
  |  Branch (465:35): [True: 0, False: 0]
  ------------------
  466|      0|        cipop(mrb);
  467|      0|      }
  468|      0|    }
  469|      0|  }
  470|      0|  MRB_END_EXC(&c_jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
  471|       |
  472|  1.74k|  mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  1.74k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  473|  1.74k|  mrb_gc_protect(mrb, result);
  474|  1.74k|  return result;
  475|  1.74k|}
mrb_funcall_id:
  505|  59.0k|{
  506|  59.0k|  mrb_value argv[MRB_FUNCALL_ARGC_MAX];
  507|  59.0k|  va_list ap;
  508|       |
  509|  59.0k|  if (argc > MRB_FUNCALL_ARGC_MAX) {
  ------------------
  |  |  481|  59.0k|#define MRB_FUNCALL_ARGC_MAX 16
  ------------------
  |  Branch (509:7): [True: 0, False: 59.0k]
  ------------------
  510|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=" MRB_STRINGIZE(MRB_FUNCALL_ARGC_MAX) ")");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  511|      0|  }
  512|       |
  513|  59.0k|  va_start(ap, argc);
  514|   118k|  for (mrb_int i = 0; i < argc; i++) {
  ------------------
  |  Branch (514:23): [True: 59.0k, False: 59.0k]
  ------------------
  515|  59.0k|    argv[i] = va_arg(ap, mrb_value);
  516|  59.0k|  }
  517|  59.0k|  va_end(ap);
  518|  59.0k|  return mrb_funcall_argv(mrb, self, mid, argc, argv);
  519|  59.0k|}
mrb_ci_bidx:
  545|  12.2k|{
  546|  12.2k|  return ci_bidx(ci);
  547|  12.2k|}
mrb_ci_nregs:
  551|  93.8k|{
  552|  93.8k|  const struct RProc *p;
  553|       |
  554|  93.8k|  if (!ci) return 4;
  ------------------
  |  Branch (554:7): [True: 0, False: 93.8k]
  ------------------
  555|  93.8k|  mrb_int nregs = ci_bidx(ci) + 1; /* self + args + kargs + blk */
  556|  93.8k|  p = ci->proc;
  557|  93.8k|  if (p && !MRB_PROC_CFUNC_P(p) && p->body.irep && p->body.irep->nregs > nregs) {
  ------------------
  |  |   65|  96.5k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|  2.76k|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  ------------------
  |  Branch (557:7): [True: 2.76k, False: 91.0k]
  |  Branch (557:12): [True: 2.76k, False: 0]
  |  Branch (557:36): [True: 2.76k, False: 0]
  |  Branch (557:52): [True: 2.76k, False: 0]
  ------------------
  558|  2.76k|    return p->body.irep->nregs;
  559|  2.76k|  }
  560|  91.0k|  return nregs;
  561|  93.8k|}
mrb_funcall_with_block:
  647|  60.8k|{
  648|  60.8k|  mrb_value val;
  649|  60.8k|  int ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  60.8k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
  650|       |
  651|  60.8k|  if (!mrb->jmp) {
  ------------------
  |  Branch (651:7): [True: 0, False: 60.8k]
  ------------------
  652|      0|    struct mrb_jmpbuf c_jmp;
  653|      0|    ptrdiff_t nth_ci = mrb->c->ci - mrb->c->cibase;
  654|       |
  655|      0|    MRB_TRY(&c_jmp) {
  ------------------
  |  |   44|      0|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|      0|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  656|      0|      mrb->jmp = &c_jmp;
  657|       |      /* recursive call */
  658|      0|      val = mrb_funcall_with_block(mrb, self, mid, argc, argv, blk);
  659|      0|      mrb->jmp = NULL;
  660|      0|    }
  661|      0|    MRB_CATCH(&c_jmp) { /* error */
  ------------------
  |  |   45|      0|#define MRB_CATCH(buf) } else {
  ------------------
  662|      0|      while (nth_ci < (mrb->c->ci - mrb->c->cibase)) {
  ------------------
  |  Branch (662:14): [True: 0, False: 0]
  ------------------
  663|      0|        cipop(mrb);
  664|      0|      }
  665|      0|      mrb->jmp = 0;
  666|      0|      val = mrb_obj_value(mrb->exc);
  667|      0|    }
  668|      0|    MRB_END_EXC(&c_jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
  669|      0|    mrb->jmp = NULL;
  670|      0|  }
  671|  60.8k|  else {
  672|  60.8k|    mrb_method_t m;
  673|  60.8k|    mrb_callinfo *ci = mrb->c->ci;
  674|  60.8k|    mrb_int n = mrb_ci_nregs(ci);
  675|       |
  676|  60.8k|    if (!mrb->c->stbase) {
  ------------------
  |  Branch (676:9): [True: 0, False: 60.8k]
  ------------------
  677|      0|      stack_init(mrb);
  678|      0|    }
  679|  60.8k|    if (ci - mrb->c->cibase > MRB_CALL_LEVEL_MAX) {
  ------------------
  |  |   45|  60.8k|#define MRB_CALL_LEVEL_MAX 512
  ------------------
  |  Branch (679:9): [True: 0, False: 60.8k]
  ------------------
  680|      0|      mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
  681|      0|    }
  682|  60.8k|    blk = ensure_block(mrb, blk);
  683|  60.8k|    ci = cipush(mrb, n, CINFO_DIRECT, NULL, NULL, BLK_PTR(blk), 0, 0);
  ------------------
  |  |  336|  60.8k|#define CINFO_DIRECT  2 // called method from C
  ------------------
                  ci = cipush(mrb, n, CINFO_DIRECT, NULL, NULL, BLK_PTR(blk), 0, 0);
  ------------------
  |  |  339|  60.8k|#define BLK_PTR(b) ((mrb_proc_p(b)) ? mrb_proc_ptr(b) : NULL)
  |  |  ------------------
  |  |  |  |  197|  60.8k|#define mrb_proc_p(o) WORDBOX_OBJ_TYPE_P(o, PROC)
  |  |  |  |  ------------------
  |  |  |  |  |  |   78|  60.8k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  148|   121k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   71|   121k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 60.8k]
  |  |  |  |  |  |  |  |  |  Branch (148:63): [True: 60.8k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define BLK_PTR(b) ((mrb_proc_p(b)) ? mrb_proc_ptr(b) : NULL)
  |  |  ------------------
  |  |  |  |   90|      0|#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  684|  60.8k|    funcall_args_capture(mrb, 0, argc, argv, blk, ci);
  685|  60.8k|    ci->u.target_class = mrb_class(mrb, self);
  686|  60.8k|    m = mrb_vm_find_method(mrb, ci->u.target_class, &ci->u.target_class, mid);
  687|  60.8k|    if (MRB_METHOD_UNDEF_P(m)) {
  ------------------
  |  |  115|  60.8k|#define MRB_METHOD_UNDEF_P(m) ((m)==0)
  |  |  ------------------
  |  |  |  Branch (115:31): [True: 0, False: 60.8k]
  |  |  ------------------
  ------------------
  688|      0|      m = prepare_missing(mrb, ci, self, mid, mrb_nil_value(), FALSE);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
  689|      0|    }
  690|  60.8k|    else {
  691|  60.8k|      ci->mid = mid;
  692|  60.8k|    }
  693|  60.8k|    ci->proc = MRB_METHOD_PROC_P(m) ? MRB_METHOD_PROC(m) : NULL;
  ------------------
  |  |  113|  60.8k|#define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
  |  |  ------------------
  |  |  |  |  107|  60.8k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|  60.8k|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (113:30): [True: 21, False: 60.8k]
  |  |  ------------------
  ------------------
                  ci->proc = MRB_METHOD_PROC_P(m) ? MRB_METHOD_PROC(m) : NULL;
  ------------------
  |  |  114|     21|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  ------------------
  694|       |
  695|  60.8k|    if (MRB_METHOD_CFUNC_P(m)) {
  ------------------
  |  |  131|  60.8k|#define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |  107|  60.8k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|  60.8k|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (107:30): [True: 60.8k, False: 21]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   54|  60.8k|#  define TRUE 1
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |  114|     21|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (114:28): [True: 21, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   65|     21|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|     21|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  ------------------
  |  |  |  Branch (131:31): [True: 60.8k, False: 21]
  |  |  ------------------
  ------------------
  696|  60.8k|      ci->stack[0] = self;
  697|  60.8k|      val = MRB_METHOD_CFUNC(m)(mrb, self);
  ------------------
  |  |  132|  60.8k|#define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
  |  |  ------------------
  |  |  |  |  107|  60.8k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|  60.8k|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (107:30): [True: 60.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
  |  |  ------------------
  |  |  |  |  110|  60.8k|#define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)>>2))
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
  |  |  ------------------
  |  |  |  |  114|      0|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (114:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
  |  |  ------------------
  |  |  |  |   65|      0|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:29): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
  |  |  ------------------
  |  |  |  |   66|      0|#define MRB_PROC_CFUNC(p) (p)->body.func
  |  |  ------------------
  ------------------
  698|  60.8k|      cipop(mrb);
  699|  60.8k|    }
  700|     21|    else {
  701|     21|      ci->cci = CINFO_SKIP;
  ------------------
  |  |  335|     21|#define CINFO_SKIP    1 // ignited mruby VM from C
  ------------------
  702|     21|      val = mrb_run(mrb, ci->proc, self);
  703|     21|    }
  704|  60.8k|  }
  705|  60.8k|  mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  60.8k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
  706|  60.8k|  mrb_gc_protect(mrb, val);
  707|  60.8k|  return val;
  708|  60.8k|}
mrb_funcall_argv:
  712|  60.8k|{
  713|  60.8k|  return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value());
  714|  60.8k|}
mrb_mod_module_eval:
  935|  1.74k|{
  936|  1.74k|  mrb_value a, b;
  937|       |
  938|  1.74k|  if (mrb_get_args(mrb, "|S&", &a, &b) == 1) {
  ------------------
  |  Branch (938:7): [True: 0, False: 1.74k]
  ------------------
  939|      0|    mrb_raise(mrb, E_NOTIMP_ERROR, "module_eval/class_eval with string not implemented");
  ------------------
  |  | 1387|      0|#define E_NOTIMP_ERROR       mrb_exc_get_id(mrb, MRB_ERROR_SYM(NotImplementedError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  940|      0|  }
  941|  1.74k|  return eval_under(mrb, mod, b, mrb_class_ptr(mod));
  ------------------
  |  |   24|  1.74k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  1.74k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  942|  1.74k|}
mrb_vm_run:
 1290|  46.9k|{
 1291|  46.9k|  const mrb_irep *irep = proc->body.irep;
 1292|  46.9k|  mrb_value result;
 1293|  46.9k|  struct mrb_context *c = mrb->c;
 1294|  46.9k|  ptrdiff_t cioff = c->ci - c->cibase;
 1295|  46.9k|  mrb_int nregs = irep->nregs;
 1296|       |
 1297|  46.9k|  if (!c->stbase) {
  ------------------
  |  Branch (1297:7): [True: 1.74k, False: 45.1k]
  ------------------
 1298|  1.74k|    stack_init(mrb);
 1299|  1.74k|  }
 1300|  46.9k|  if (stack_keep > nregs)
  ------------------
  |  Branch (1300:7): [True: 0, False: 46.9k]
  ------------------
 1301|      0|    nregs = stack_keep;
 1302|  46.9k|  else {
 1303|  46.9k|    struct REnv *e = CI_ENV(mrb->c->ci);
  ------------------
  |  |  287|  46.9k|#define CI_ENV(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env : NULL)
  |  |  ------------------
  |  |  |  Branch (287:22): [True: 46.9k, False: 0]
  |  |  |  Branch (287:37): [True: 0, False: 46.9k]
  |  |  ------------------
  ------------------
 1304|  46.9k|    if (stack_keep == 0 || (e && irep->nlocals < MRB_ENV_LEN(e))) {
  ------------------
  |  |   27|      0|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  |  Branch (1304:9): [True: 46.9k, False: 21]
  |  Branch (1304:29): [True: 0, False: 21]
  |  Branch (1304:34): [True: 0, False: 0]
  ------------------
 1305|  46.9k|      ci_env_set(mrb->c->ci, NULL);
 1306|  46.9k|      mrb_env_unshare(mrb, e, FALSE);
  ------------------
  |  |   51|  46.9k|#  define FALSE 0
  ------------------
 1307|  46.9k|    }
 1308|  46.9k|  }
 1309|  46.9k|  stack_extend(mrb, nregs);
 1310|  46.9k|  stack_clear(c->ci->stack + stack_keep, nregs - stack_keep);
 1311|  46.9k|  c->ci->stack[0] = self;
 1312|  46.9k|  result = mrb_vm_exec(mrb, proc, irep->iseq);
 1313|  46.9k|  if (mrb->c != c) {
  ------------------
  |  Branch (1313:7): [True: 0, False: 46.9k]
  ------------------
 1314|      0|    if (mrb->c->fib) {
  ------------------
  |  Branch (1314:9): [True: 0, False: 0]
  ------------------
 1315|      0|      mrb_write_barrier(mrb, (struct RBasic*)mrb->c->fib);
 1316|      0|    }
 1317|      0|    mrb->c = c;
 1318|      0|  }
 1319|  46.9k|  else if (c->ci - c->cibase > cioff) {
  ------------------
  |  Branch (1319:12): [True: 0, False: 46.9k]
  ------------------
 1320|      0|    c->ci = c->cibase + cioff;
 1321|      0|  }
 1322|  46.9k|  return result;
 1323|  46.9k|}
mrb_vm_exec:
 1361|  46.9k|{
 1362|       |  /* mrb_assert(MRB_PROC_CFUNC_P(proc)) */
 1363|  46.9k|  const mrb_irep *irep = proc->body.irep;
 1364|  46.9k|  const mrb_pool_value *pool = irep->pool;
 1365|  46.9k|  const mrb_sym *syms = irep->syms;
 1366|  46.9k|  mrb_code insn;
 1367|  46.9k|  int ai = mrb_gc_arena_save(mrb);
  ------------------
  |  | 1306|  46.9k|#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx)
  ------------------
 1368|  46.9k|  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
 1369|  46.9k|  struct mrb_jmpbuf c_jmp;
 1370|  46.9k|  uint32_t a;
 1371|  46.9k|  uint16_t b;
 1372|  46.9k|  uint16_t c;
 1373|  46.9k|  mrb_sym mid;
 1374|  46.9k|  const struct mrb_irep_catch_handler *ch;
 1375|       |
 1376|  46.9k|#ifndef MRB_USE_VM_SWITCH_DISPATCH
 1377|  46.9k|  static const void * const optable[] = {
 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
 1379|  46.9k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|  46.9k|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   16|  46.9k|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   17|  46.9k|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   18|  46.9k|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   19|  46.9k|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   20|  46.9k|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   21|  46.9k|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   22|  46.9k|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   23|  46.9k|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   24|  46.9k|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   25|  46.9k|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   26|  46.9k|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   27|  46.9k|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   28|  46.9k|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   29|  46.9k|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   30|  46.9k|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   31|  46.9k|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   32|  46.9k|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   33|  46.9k|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   34|  46.9k|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   35|  46.9k|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   36|  46.9k|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   37|  46.9k|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   38|  46.9k|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   39|  46.9k|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   40|  46.9k|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   41|  46.9k|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   42|  46.9k|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   43|  46.9k|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   44|  46.9k|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   45|  46.9k|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   46|  46.9k|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   47|  46.9k|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   48|  46.9k|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   49|  46.9k|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   50|  46.9k|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   51|  46.9k|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   52|  46.9k|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   53|  46.9k|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   54|  46.9k|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   55|  46.9k|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   56|  46.9k|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   57|  46.9k|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   58|  46.9k|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   59|  46.9k|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   60|  46.9k|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   61|  46.9k|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   62|  46.9k|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   63|  46.9k|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   64|  46.9k|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   65|  46.9k|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   66|  46.9k|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   67|  46.9k|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   68|  46.9k|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   69|  46.9k|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   70|  46.9k|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   71|  46.9k|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   72|  46.9k|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   73|  46.9k|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   74|  46.9k|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   75|  46.9k|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   76|  46.9k|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   77|  46.9k|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   78|  46.9k|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   79|  46.9k|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   80|  46.9k|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   81|  46.9k|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   82|  46.9k|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   83|  46.9k|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   84|  46.9k|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   85|  46.9k|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   86|  46.9k|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   87|  46.9k|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   88|  46.9k|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   89|  46.9k|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   90|  46.9k|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   91|  46.9k|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   92|  46.9k|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   93|  46.9k|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   94|  46.9k|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   95|  46.9k|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   96|  46.9k|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   97|  46.9k|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   98|  46.9k|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |   99|  46.9k|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  100|  46.9k|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  101|  46.9k|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  102|  46.9k|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  103|  46.9k|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  104|  46.9k|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  105|  46.9k|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  106|  46.9k|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  107|  46.9k|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  108|  46.9k|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  109|  46.9k|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  110|  46.9k|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  111|  46.9k|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  112|  46.9k|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  113|  46.9k|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  114|  46.9k|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  115|  46.9k|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  116|  46.9k|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  117|  46.9k|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  118|  46.9k|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  119|  46.9k|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  |  |  120|  46.9k|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  | 1378|  46.9k|#define OPCODE(x,_) &&L_OP_ ## x,
  |  |  ------------------
  ------------------
 1380|  46.9k|#undef OPCODE
 1381|  46.9k|  };
 1382|  46.9k|#endif
 1383|       |
 1384|  46.9k|  mrb_bool exc_catched = FALSE;
  ------------------
  |  |   51|  46.9k|#  define FALSE 0
  ------------------
 1385|  47.3k|RETRY_TRY_BLOCK:
 1386|       |
 1387|  47.3k|  MRB_TRY(&c_jmp) {
  ------------------
  |  |   44|  47.3k|#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
  |  |  ------------------
  |  |  |  |   40|  47.3k|#define MRB_SETJMP setjmp
  |  |  ------------------
  |  |  |  Branch (44:26): [True: 47.3k, False: 0]
  |  |  ------------------
  ------------------
 1388|       |
 1389|  47.3k|  if (exc_catched) {
  ------------------
  |  Branch (1389:7): [True: 400, False: 46.9k]
  ------------------
 1390|    400|    exc_catched = FALSE;
  ------------------
  |  |   51|    400|#  define FALSE 0
  ------------------
 1391|    400|    mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|    400|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 1392|    400|    if (mrb->exc && mrb->exc->tt == MRB_TT_BREAK)
  ------------------
  |  Branch (1392:9): [True: 400, False: 0]
  |  Branch (1392:21): [True: 0, False: 400]
  ------------------
 1393|      0|      goto L_BREAK;
 1394|    400|    goto L_RAISE;
 1395|    400|  }
 1396|  46.9k|  mrb->jmp = &c_jmp;
 1397|  46.9k|  CI_PROC_SET(mrb->c->ci, proc);
  ------------------
  |  |  256|  46.9k|#define CI_PROC_SET(ci, p) do {\
  |  |  257|  46.9k|  ci->proc = p;\
  |  |  258|  46.9k|  ci->pc = (p && !MRB_PROC_CFUNC_P(p)) ? p->body.irep->iseq : NULL;\
  |  |  ------------------
  |  |  |  |   65|  46.9k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  46.9k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (258:13): [True: 46.9k, False: 0]
  |  |  |  Branch (258:18): [True: 46.9k, False: 0]
  |  |  ------------------
  |  |  259|  46.9k|} while (0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1398|       |
 1399|  46.9k|  INIT_DISPATCH {
  ------------------
  |  | 1279|  46.9k|#define INIT_DISPATCH JUMP; return mrb_nil_value();
  |  |  ------------------
  |  |  |  | 1282|  46.9k|#define JUMP NEXT
  |  |  |  |  ------------------
  |  |  |  |  |  | 1281|  46.9k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1260|  46.9k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1252|  46.9k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 46.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1400|      0|    CASE(OP_NOP, Z) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1401|       |      /* do nothing */
 1402|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1403|      0|    }
 1404|       |
 1405|  2.26M|    CASE(OP_MOVE, BB) {
  ------------------
  |  | 1280|  1.13M|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1406|  2.26M|      regs[a] = regs[b];
  ------------------
  |  | 1335|  1.13M|#define regs (mrb->c->ci->stack)
  ------------------
                    regs[a] = regs[b];
  ------------------
  |  | 1335|  1.13M|#define regs (mrb->c->ci->stack)
  ------------------
 1407|  2.26M|      NEXT;
  ------------------
  |  | 1281|  1.13M|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.13M|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.13M|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.13M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1408|  2.26M|    }
 1409|       |
 1410|  2.26M|    CASE(OP_LOADL, BB) {
  ------------------
  |  | 1280|  1.13M|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1411|    542|      switch (pool[b].tt) {   /* number */
 1412|      0|      case IREP_TT_INT32:
  ------------------
  |  Branch (1412:7): [True: 0, False: 356]
  ------------------
 1413|      0|        regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i32);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1414|      0|        break;
 1415|    356|      case IREP_TT_INT64:
  ------------------
  |  Branch (1415:7): [True: 356, False: 0]
  ------------------
 1416|    356|#if defined(MRB_INT64)
 1417|    356|        regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64);
  ------------------
  |  | 1335|    356|#define regs (mrb->c->ci->stack)
  ------------------
 1418|    356|        break;
 1419|       |#else
 1420|       |#if defined(MRB_64BIT)
 1421|       |        if (INT32_MIN <= pool[b].u.i64 && pool[b].u.i64 <= INT32_MAX) {
 1422|       |          regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64);
 1423|       |          break;
 1424|       |        }
 1425|       |#endif
 1426|       |        goto L_INT_OVERFLOW;
 1427|       |#endif
 1428|      0|      case IREP_TT_BIGINT:
  ------------------
  |  Branch (1428:7): [True: 0, False: 356]
  ------------------
 1429|      0|#ifdef MRB_USE_BIGINT
 1430|      0|        {
 1431|      0|          const char *s = pool[b].u.str;
 1432|      0|          regs[a] = mrb_bint_new_str(mrb, s+2, (uint8_t)s[0], s[1]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1433|      0|        }
 1434|      0|        break;
 1435|       |#else
 1436|       |        goto L_INT_OVERFLOW;
 1437|       |#endif
 1438|      0|#ifndef MRB_NO_FLOAT
 1439|      0|      case IREP_TT_FLOAT:
  ------------------
  |  Branch (1439:7): [True: 0, False: 356]
  ------------------
 1440|      0|        regs[a] = mrb_float_value(mrb, pool[b].u.f);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1441|      0|        break;
 1442|      0|#endif
 1443|      0|      default:
  ------------------
  |  Branch (1443:7): [True: 0, False: 356]
  ------------------
 1444|       |        /* should not happen (tt:string) */
 1445|      0|        regs[a] = mrb_nil_value();
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1446|      0|        break;
 1447|    542|      }
 1448|    356|      NEXT;
  ------------------
  |  | 1281|    356|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|    356|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|    356|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 356]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1449|    356|    }
 1450|       |
 1451|  14.5k|    CASE(OP_LOADI, BB) {
  ------------------
  |  | 1280|  7.58k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1452|  14.5k|      SET_FIXNUM_VALUE(regs[a], b);
  ------------------
  |  |  215|  7.58k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  7.58k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
 1453|  14.5k|      NEXT;
  ------------------
  |  | 1281|  7.58k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  7.58k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  7.58k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 7.58k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1454|  14.5k|    }
 1455|       |
 1456|  14.5k|    CASE(OP_LOADINEG, BB) {
  ------------------
  |  | 1280|  7.58k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1457|  2.16k|      SET_FIXNUM_VALUE(regs[a], -b);
  ------------------
  |  |  215|  1.10k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|  1.10k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
 1458|  2.16k|      NEXT;
  ------------------
  |  | 1281|  1.10k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.10k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.10k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.10k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1459|  2.16k|    }
 1460|       |
 1461|  2.16k|    CASE(OP_LOADI__1,B) goto L_LOADI;
  ------------------
  |  | 1280|  1.10k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1462|  57.8k|    CASE(OP_LOADI_0,B) goto L_LOADI;
  ------------------
  |  | 1280|  57.8k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1463|   337k|    CASE(OP_LOADI_1,B) goto L_LOADI;
  ------------------
  |  | 1280|   337k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1464|   337k|    CASE(OP_LOADI_2,B) goto L_LOADI;
  ------------------
  |  | 1280|   337k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1465|  4.86k|    CASE(OP_LOADI_3,B) goto L_LOADI;
  ------------------
  |  | 1280|  4.86k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1466|  2.95k|    CASE(OP_LOADI_4,B) goto L_LOADI;
  ------------------
  |  | 1280|  2.95k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1467|  2.95k|    CASE(OP_LOADI_5,B) goto L_LOADI;
  ------------------
  |  | 1280|  2.95k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1468|  3.80k|    CASE(OP_LOADI_6,B) goto L_LOADI;
  ------------------
  |  | 1280|  3.80k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1469|  3.80k|    CASE(OP_LOADI_7, B) {
  ------------------
  |  | 1280|  3.80k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1470|   408k|    L_LOADI:
 1471|   408k|      SET_FIXNUM_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
  ------------------
  |  |  215|   408k|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|   408k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
 1472|   408k|      NEXT;
  ------------------
  |  | 1281|   408k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   408k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   408k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 408k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1473|   408k|    }
 1474|       |
 1475|   408k|    CASE(OP_LOADI16, BS) {
  ------------------
  |  | 1280|   408k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1476|    450|      SET_FIXNUM_VALUE(regs[a], (mrb_int)(int16_t)b);
  ------------------
  |  |  215|    230|#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
  |  |  ------------------
  |  |  |  |   74|    230|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
 1477|    450|      NEXT;
  ------------------
  |  | 1281|    230|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|    230|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|    230|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 230]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1478|    450|    }
 1479|       |
 1480|    450|    CASE(OP_LOADI32, BSS) {
  ------------------
  |  | 1280|    230|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1481|    232|      SET_INT_VALUE(mrb, regs[a], (int32_t)(((uint32_t)b<<16)+c));
  ------------------
  |  |  214|    119|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  ------------------
 1482|    232|      NEXT;
  ------------------
  |  | 1281|    119|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|    119|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|    119|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 119]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1483|    232|    }
 1484|       |
 1485|   185k|    CASE(OP_LOADSYM, BB) {
  ------------------
  |  | 1280|  92.9k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1486|   185k|      SET_SYM_VALUE(regs[a], syms[b]);
  ------------------
  |  |  216|  92.9k|#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
  |  |  ------------------
  |  |  |  |   74|  92.9k|  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
  |  |  ------------------
  ------------------
 1487|   185k|      NEXT;
  ------------------
  |  | 1281|  92.9k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  92.9k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  92.9k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 92.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1488|   185k|    }
 1489|       |
 1490|   845k|    CASE(OP_LOADNIL, B) {
  ------------------
  |  | 1280|   422k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1491|   845k|      SET_NIL_VALUE(regs[a]);
  ------------------
  |  |  210|   422k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 1492|   845k|      NEXT;
  ------------------
  |  | 1281|   422k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   422k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   422k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 422k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1493|   845k|    }
 1494|       |
 1495|   845k|    CASE(OP_LOADSELF, B) {
  ------------------
  |  | 1280|   422k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1496|   781k|      regs[a] = regs[0];
  ------------------
  |  | 1335|   390k|#define regs (mrb->c->ci->stack)
  ------------------
                    regs[a] = regs[0];
  ------------------
  |  | 1335|   390k|#define regs (mrb->c->ci->stack)
  ------------------
 1497|   781k|      NEXT;
  ------------------
  |  | 1281|   390k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   390k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   390k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 390k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1498|   781k|    }
 1499|       |
 1500|   781k|    CASE(OP_LOADT, B) {
  ------------------
  |  | 1280|   390k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1501|  7.97k|      SET_TRUE_VALUE(regs[a]);
  ------------------
  |  |  212|  3.98k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  ------------------
 1502|  7.97k|      NEXT;
  ------------------
  |  | 1281|  3.98k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  3.98k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  3.98k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 3.98k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1503|  7.97k|    }
 1504|       |
 1505|   176k|    CASE(OP_LOADF, B) {
  ------------------
  |  | 1280|  88.3k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1506|   176k|      SET_FALSE_VALUE(regs[a]);
  ------------------
  |  |  211|  88.3k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  ------------------
 1507|   176k|      NEXT;
  ------------------
  |  | 1281|  88.3k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  88.3k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  88.3k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 88.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1508|   176k|    }
 1509|       |
 1510|   176k|    CASE(OP_GETGV, BB) {
  ------------------
  |  | 1280|  88.3k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1511|      0|      mrb_value val = mrb_gv_get(mrb, syms[b]);
 1512|      0|      regs[a] = val;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1513|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1514|      0|    }
 1515|       |
 1516|  10.4k|    CASE(OP_SETGV, BB) {
  ------------------
  |  | 1280|  5.23k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1517|  10.4k|      mrb_gv_set(mrb, syms[b], regs[a]);
  ------------------
  |  | 1335|  5.23k|#define regs (mrb->c->ci->stack)
  ------------------
 1518|  10.4k|      NEXT;
  ------------------
  |  | 1281|  5.23k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  5.23k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  5.23k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 5.23k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1519|  10.4k|    }
 1520|       |
 1521|  10.4k|    CASE(OP_GETSV, BB) {
  ------------------
  |  | 1280|  5.23k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1522|      0|      mrb_value val = mrb_vm_special_get(mrb, syms[b]);
 1523|      0|      regs[a] = val;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1524|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1525|      0|    }
 1526|       |
 1527|      0|    CASE(OP_SETSV, BB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1528|      0|      mrb_vm_special_set(mrb, syms[b], regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1529|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1530|      0|    }
 1531|       |
 1532|  40.9k|    CASE(OP_GETIV, BB) {
  ------------------
  |  | 1280|  20.4k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1533|  40.9k|      regs[a] = mrb_iv_get(mrb, regs[0], syms[b]);
  ------------------
  |  | 1335|  20.4k|#define regs (mrb->c->ci->stack)
  ------------------
                    regs[a] = mrb_iv_get(mrb, regs[0], syms[b]);
  ------------------
  |  | 1335|  20.4k|#define regs (mrb->c->ci->stack)
  ------------------
 1534|  40.9k|      NEXT;
  ------------------
  |  | 1281|  20.4k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  20.4k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  20.4k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 20.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1535|  40.9k|    }
 1536|       |
 1537|   482k|    CASE(OP_SETIV, BB) {
  ------------------
  |  | 1280|   241k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1538|   482k|      mrb_iv_set(mrb, regs[0], syms[b], regs[a]);
  ------------------
  |  | 1335|   241k|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_iv_set(mrb, regs[0], syms[b], regs[a]);
  ------------------
  |  | 1335|   241k|#define regs (mrb->c->ci->stack)
  ------------------
 1539|   482k|      NEXT;
  ------------------
  |  | 1281|   241k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   241k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   241k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 241k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1540|   482k|    }
 1541|       |
 1542|   482k|    CASE(OP_GETCV, BB) {
  ------------------
  |  | 1280|   241k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1543|      0|      mrb_value val;
 1544|      0|      val = mrb_vm_cv_get(mrb, syms[b]);
 1545|      0|      regs[a] = val;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1546|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1547|      0|    }
 1548|       |
 1549|  3.49k|    CASE(OP_SETCV, BB) {
  ------------------
  |  | 1280|  1.74k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1550|  3.49k|      mrb_vm_cv_set(mrb, syms[b], regs[a]);
  ------------------
  |  | 1335|  1.74k|#define regs (mrb->c->ci->stack)
  ------------------
 1551|  3.49k|      NEXT;
  ------------------
  |  | 1281|  1.74k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.74k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.74k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1552|  3.49k|    }
 1553|       |
 1554|   113k|    CASE(OP_GETIDX, B) {
  ------------------
  |  | 1280|  56.7k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1555|   113k|      mrb_value va = regs[a], vb = regs[a+1];
  ------------------
  |  | 1335|  56.7k|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_value va = regs[a], vb = regs[a+1];
  ------------------
  |  | 1335|  56.7k|#define regs (mrb->c->ci->stack)
  ------------------
 1556|   113k|      switch (mrb_type(va)) {
 1557|  56.7k|      case MRB_TT_ARRAY:
  ------------------
  |  Branch (1557:7): [True: 56.7k, False: 0]
  ------------------
 1558|  56.7k|        if (!mrb_integer_p(vb)) goto getidx_fallback;
  ------------------
  |  |  171|  56.7k|#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   76|   113k|  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:3): [True: 55.9k, False: 869]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
  |  |  ------------------
  |  |  |  |   78|    869|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  1.73k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  1.73k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 869, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1559|  55.9k|        regs[a] = mrb_ary_entry(va, mrb_integer(vb));
  ------------------
  |  | 1335|  55.9k|#define regs (mrb->c->ci->stack)
  ------------------
                      regs[a] = mrb_ary_entry(va, mrb_integer(vb));
  ------------------
  |  |  166|  55.9k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1560|  55.9k|        break;
 1561|      0|      case MRB_TT_HASH:
  ------------------
  |  Branch (1561:7): [True: 0, False: 56.7k]
  ------------------
 1562|      0|        va = mrb_hash_get(mrb, va, vb);
 1563|      0|        regs[a] = va;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1564|      0|        break;
 1565|      0|      case MRB_TT_STRING:
  ------------------
  |  Branch (1565:7): [True: 0, False: 56.7k]
  ------------------
 1566|      0|        switch (mrb_type(vb)) {
 1567|      0|        case MRB_TT_INTEGER:
  ------------------
  |  Branch (1567:9): [True: 0, False: 0]
  ------------------
 1568|      0|        case MRB_TT_STRING:
  ------------------
  |  Branch (1568:9): [True: 0, False: 0]
  ------------------
 1569|      0|        case MRB_TT_RANGE:
  ------------------
  |  Branch (1569:9): [True: 0, False: 0]
  ------------------
 1570|      0|          va = mrb_str_aref(mrb, va, vb, mrb_undef_value());
 1571|      0|          regs[a] = va;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1572|      0|          break;
 1573|      0|        default:
  ------------------
  |  Branch (1573:9): [True: 0, False: 0]
  ------------------
 1574|      0|          goto getidx_fallback;
 1575|      0|        }
 1576|      0|        break;
 1577|      0|      default:
  ------------------
  |  Branch (1577:7): [True: 0, False: 56.7k]
  ------------------
 1578|    869|      getidx_fallback:
 1579|    869|        mid = MRB_OPSYM(aref);
  ------------------
  |  |   12|    869|#define MRB_OPSYM(name) MRB_OPSYM__##name
  ------------------
 1580|    869|        goto L_SEND_SYM;
 1581|   113k|      }
 1582|  55.9k|      NEXT;
  ------------------
  |  | 1281|  55.9k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  55.9k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  55.9k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 55.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1583|  55.9k|    }
 1584|       |
 1585|  55.9k|    CASE(OP_SETIDX, B) {
  ------------------
  |  | 1280|  55.9k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1586|  13.0k|      c = 2;
 1587|  13.0k|      mid = MRB_OPSYM(aset);
  ------------------
  |  |   12|  13.0k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  ------------------
 1588|  13.0k|      SET_NIL_VALUE(regs[a+3]);
  ------------------
  |  |  210|  13.0k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 1589|  13.0k|      goto L_SENDB_SYM;
 1590|  13.0k|    }
 1591|       |
 1592|   466k|    CASE(OP_GETCONST, BB) {
  ------------------
  |  | 1280|   233k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1593|   466k|      mrb_value v = mrb_vm_const_get(mrb, syms[b]);
 1594|   466k|      regs[a] = v;
  ------------------
  |  | 1335|   233k|#define regs (mrb->c->ci->stack)
  ------------------
 1595|   466k|      NEXT;
  ------------------
  |  | 1281|   233k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   233k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   233k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 233k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1596|   466k|    }
 1597|       |
 1598|   466k|    CASE(OP_SETCONST, BB) {
  ------------------
  |  | 1280|   233k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1599|  31.4k|      mrb_vm_const_set(mrb, syms[b], regs[a]);
  ------------------
  |  | 1335|  15.7k|#define regs (mrb->c->ci->stack)
  ------------------
 1600|  31.4k|      NEXT;
  ------------------
  |  | 1281|  15.7k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  15.7k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  15.7k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 15.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1601|  31.4k|    }
 1602|       |
 1603|  31.4k|    CASE(OP_GETMCNST, BB) {
  ------------------
  |  | 1280|  15.7k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1604|  8.59k|      mrb_value v = mrb_const_get(mrb, regs[a], syms[b]);
  ------------------
  |  | 1335|  4.40k|#define regs (mrb->c->ci->stack)
  ------------------
 1605|  8.59k|      regs[a] = v;
  ------------------
  |  | 1335|  4.40k|#define regs (mrb->c->ci->stack)
  ------------------
 1606|  8.59k|      NEXT;
  ------------------
  |  | 1281|  4.40k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  4.40k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  4.40k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 4.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1607|  8.59k|    }
 1608|       |
 1609|  8.59k|    CASE(OP_SETMCNST, BB) {
  ------------------
  |  | 1280|  4.40k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1610|      0|      mrb_const_set(mrb, regs[a+1], syms[b], regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_const_set(mrb, regs[a+1], syms[b], regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1611|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1612|      0|    }
 1613|       |
 1614|      0|    CASE(OP_GETUPVAR, BBB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1615|      0|      struct REnv *e = uvenv(mrb, c);
 1616|       |
 1617|      0|      if (e && b < MRB_ENV_LEN(e)) {
  ------------------
  |  |   27|      0|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  |  Branch (1617:11): [True: 0, False: 0]
  |  Branch (1617:16): [True: 0, False: 0]
  ------------------
 1618|      0|        regs[a] = e->stack[b];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1619|      0|      }
 1620|      0|      else {
 1621|      0|        regs[a] = mrb_nil_value();
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1622|      0|      }
 1623|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1624|      0|    }
 1625|       |
 1626|      0|    CASE(OP_SETUPVAR, BBB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1627|      0|      struct REnv *e = uvenv(mrb, c);
 1628|       |
 1629|      0|      if (e) {
  ------------------
  |  Branch (1629:11): [True: 0, False: 0]
  ------------------
 1630|      0|        if (b < MRB_ENV_LEN(e)) {
  ------------------
  |  |   27|      0|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  |  Branch (1630:13): [True: 0, False: 0]
  ------------------
 1631|      0|          e->stack[b] = regs[a];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1632|      0|          mrb_write_barrier(mrb, (struct RBasic*)e);
 1633|      0|        }
 1634|      0|      }
 1635|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1636|      0|    }
 1637|       |
 1638|   330k|    CASE(OP_JMP, S) {
  ------------------
  |  | 1280|   165k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1639|   330k|      pc += (int16_t)a;
 1640|   330k|      JUMP;
  ------------------
  |  | 1282|   165k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|   165k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|   165k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|   165k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 165k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1641|   330k|    }
 1642|   330k|    CASE(OP_JMPIF, BS) {
  ------------------
  |  | 1280|   165k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1643|   150k|      if (mrb_test(regs[a])) {
  ------------------
  |  |  312|  75.3k|#define mrb_test(o)   mrb_bool(o)
  |  |  ------------------
  |  |  |  |  168|  75.3k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (168:24): [True: 25.4k, False: 49.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1644|  25.4k|        pc += (int16_t)b;
 1645|  25.4k|        JUMP;
  ------------------
  |  | 1282|  25.4k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|  25.4k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  25.4k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  25.4k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 25.4k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1646|  25.4k|      }
 1647|   150k|      NEXT;
  ------------------
  |  | 1281|  75.3k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  75.3k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  75.3k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 75.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1648|   150k|    }
 1649|   635k|    CASE(OP_JMPNOT, BS) {
  ------------------
  |  | 1280|   317k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1650|   635k|      if (!mrb_test(regs[a])) {
  ------------------
  |  |  312|   317k|#define mrb_test(o)   mrb_bool(o)
  |  |  ------------------
  |  |  |  |  168|   317k|#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
  |  |  ------------------
  ------------------
  |  Branch (1650:11): [True: 176k, False: 140k]
  ------------------
 1651|   176k|        pc += (int16_t)b;
 1652|   176k|        JUMP;
  ------------------
  |  | 1282|   176k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|   176k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|   176k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|   176k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 176k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1653|   176k|      }
 1654|   635k|      NEXT;
  ------------------
  |  | 1281|   317k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   317k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   317k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 317k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1655|   635k|    }
 1656|   635k|    CASE(OP_JMPNIL, BS) {
  ------------------
  |  | 1280|   317k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1657|      0|      if (mrb_nil_p(regs[a])) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1658|      0|        pc += (int16_t)b;
 1659|      0|        JUMP;
  ------------------
  |  | 1282|      0|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1660|      0|      }
 1661|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1662|      0|    }
 1663|       |
 1664|      0|    CASE(OP_JMPUW, S) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1665|      0|      a = (uint32_t)((pc - irep->iseq) + (int16_t)a);
 1666|      0|      CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 1667|      0|        struct RBreak *brk = (struct RBreak*)mrb->exc;
 1668|      0|        mrb_value target = mrb_break_value_get(brk);
  ------------------
  |  |   45|      0|#define mrb_break_value_get(brk) ((brk)->val)
  ------------------
 1669|      0|        mrb_assert(mrb_integer_p(target));
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1670|      0|        a = (uint32_t)mrb_integer(target);
  ------------------
  |  |  166|      0|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 1671|      0|        mrb_assert(a >= 0 && a < irep->ilen);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1672|      0|      }
 1673|      0|      CHECKPOINT_MAIN(RBREAK_TAG_JUMP) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|      0|    do {
  ------------------
 1674|      0|        ch = catch_handler_find(mrb, mrb->c->ci, pc, MRB_CATCH_FILTER_ENSURE);
  ------------------
  |  | 1098|      0|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  ------------------
 1675|      0|        if (ch) {
  ------------------
  |  Branch (1675:13): [True: 0, False: 0]
  ------------------
 1676|       |          /* avoiding a jump from a catch handler into the same handler */
 1677|      0|          if (a < mrb_irep_catch_handler_unpack(ch->begin) || a >= mrb_irep_catch_handler_unpack(ch->end)) {
  ------------------
  |  |  124|      0|#define mrb_irep_catch_handler_unpack(v)    bin_to_uint32(v)
  ------------------
                        if (a < mrb_irep_catch_handler_unpack(ch->begin) || a >= mrb_irep_catch_handler_unpack(ch->end)) {
  ------------------
  |  |  124|      0|#define mrb_irep_catch_handler_unpack(v)    bin_to_uint32(v)
  ------------------
  |  Branch (1677:15): [True: 0, False: 0]
  |  Branch (1677:63): [True: 0, False: 0]
  ------------------
 1678|      0|            THROW_TAGGED_BREAK(mrb, RBREAK_TAG_JUMP, proc, mrb_fixnum_value(a));
  ------------------
  |  | 1205|      0|  do { \
  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  | 1208|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1679|      0|          }
 1680|      0|        }
 1681|      0|      }
 1682|      0|      CHECKPOINT_END(RBREAK_TAG_JUMP);
  ------------------
  |  | 1248|      0|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1683|       |
 1684|      0|      mrb->exc = NULL; /* clear break object */
 1685|      0|      pc = irep->iseq + a;
 1686|      0|      JUMP;
  ------------------
  |  | 1282|      0|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1687|      0|    }
 1688|       |
 1689|      0|    CASE(OP_EXCEPT, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1690|      0|      mrb_value exc;
 1691|       |
 1692|      0|      if (mrb->exc == NULL) {
  ------------------
  |  Branch (1692:11): [True: 0, False: 0]
  ------------------
 1693|      0|        exc = mrb_nil_value();
 1694|      0|      }
 1695|      0|      else {
 1696|      0|        switch (mrb->exc->tt) {
 1697|      0|        case MRB_TT_BREAK:
  ------------------
  |  Branch (1697:9): [True: 0, False: 0]
  ------------------
 1698|      0|        case MRB_TT_EXCEPTION:
  ------------------
  |  Branch (1698:9): [True: 0, False: 0]
  ------------------
 1699|      0|          exc = mrb_obj_value(mrb->exc);
 1700|      0|          break;
 1701|      0|        default:
  ------------------
  |  Branch (1701:9): [True: 0, False: 0]
  ------------------
 1702|      0|          mrb_assert(!"bad mrb_type");
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 1703|      0|          exc = mrb_nil_value();
 1704|      0|          break;
 1705|      0|        }
 1706|      0|        mrb->exc = NULL;
 1707|      0|      }
 1708|      0|      regs[a] = exc;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1709|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1710|      0|    }
 1711|      0|    CASE(OP_RESCUE, BB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1712|      0|      mrb_value exc = regs[a];  /* exc on stack */
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1713|      0|      mrb_value e = regs[b];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1714|      0|      struct RClass *ec;
 1715|       |
 1716|      0|      switch (mrb_type(e)) {
 1717|      0|      case MRB_TT_CLASS:
  ------------------
  |  Branch (1717:7): [True: 0, False: 0]
  ------------------
 1718|      0|      case MRB_TT_MODULE:
  ------------------
  |  Branch (1718:7): [True: 0, False: 0]
  ------------------
 1719|      0|        break;
 1720|      0|      default:
  ------------------
  |  Branch (1720:7): [True: 0, False: 0]
  ------------------
 1721|      0|        RAISE_LIT(mrb, E_TYPE_ERROR, "class or module required for rescue clause");
  ------------------
  |  | 1163|      0|#define RAISE_LIT(mrb, c, str)          RAISE_EXC(mrb, mrb_exc_new_lit(mrb, c, str))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1722|      0|      }
 1723|      0|      ec = mrb_class_ptr(e);
  ------------------
  |  |   24|      0|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1724|      0|      regs[b] = mrb_bool_value(mrb_obj_is_kind_of(mrb, exc, ec));
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1725|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1726|      0|    }
 1727|       |
 1728|      0|    CASE(OP_RAISEIF, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1729|      0|      mrb_value exc = regs[a];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1730|      0|      if (mrb_break_p(exc)) {
  ------------------
  |  |  203|      0|#define mrb_break_p(o) WORDBOX_OBJ_TYPE_P(o, BREAK)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1731|      0|        mrb->exc = mrb_obj_ptr(exc);
  ------------------
  |  |   34|      0|#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1732|      0|        goto L_BREAK;
 1733|      0|      }
 1734|      0|      mrb_exc_set(mrb, exc);
 1735|      0|      if (mrb->exc) {
  ------------------
  |  Branch (1735:11): [True: 0, False: 0]
  ------------------
 1736|      0|        goto L_RAISE;
 1737|      0|      }
 1738|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1739|      0|    }
 1740|       |
 1741|   163k|    CASE(OP_SSEND, BBB) {
  ------------------
  |  | 1280|   163k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1742|   163k|      regs[a] = regs[0];
  ------------------
  |  | 1335|   163k|#define regs (mrb->c->ci->stack)
  ------------------
                    regs[a] = regs[0];
  ------------------
  |  | 1335|   163k|#define regs (mrb->c->ci->stack)
  ------------------
 1743|   163k|      insn = OP_SEND;
 1744|   163k|    }
 1745|   163k|    goto L_SENDB;
 1746|       |
 1747|   163k|    CASE(OP_SSENDB, BBB) {
  ------------------
  |  | 1280|   163k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1748|  43.2k|      regs[a] = regs[0];
  ------------------
  |  | 1335|  43.2k|#define regs (mrb->c->ci->stack)
  ------------------
                    regs[a] = regs[0];
  ------------------
  |  | 1335|  43.2k|#define regs (mrb->c->ci->stack)
  ------------------
 1749|  43.2k|    }
 1750|  43.2k|    goto L_SENDB;
 1751|       |
 1752|   422k|    CASE(OP_SEND, BBB)
  ------------------
  |  | 1280|   422k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1753|   422k|    goto L_SENDB;
 1754|       |
 1755|  52.4k|    L_SEND_SYM:
 1756|  52.4k|    c = 1;
 1757|       |    /* push nil after arguments */
 1758|  52.4k|    SET_NIL_VALUE(regs[a+2]);
  ------------------
  |  |  210|  52.4k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 1759|  52.4k|    goto L_SENDB_SYM;
 1760|       |
 1761|  52.4k|    CASE(OP_SENDB, BBB)
  ------------------
  |  | 1280|  52.4k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1762|   653k|    L_SENDB:
 1763|   653k|    mid = syms[b];
 1764|   719k|    L_SENDB_SYM:
 1765|   719k|    {
 1766|   719k|      mrb_callinfo *ci;
 1767|   719k|      mrb_method_t m;
 1768|   719k|      mrb_value recv, blk;
 1769|   719k|      int n = c&0xf;
 1770|   719k|      int nk = (c>>4)&0xf;
 1771|   719k|      mrb_int bidx = a + mrb_bidx(n,nk);
 1772|   719k|      mrb_int new_bidx = bidx;
 1773|       |
 1774|   719k|      if (nk == CALL_MAXARGS) {
  ------------------
  |  |   84|   719k|#define CALL_MAXARGS 15
  ------------------
  |  Branch (1774:11): [True: 43.2k, False: 676k]
  ------------------
 1775|  43.2k|        mrb_ensure_hash_type(mrb, regs[a+(n==CALL_MAXARGS?1:n)+1]);
  ------------------
  |  | 1335|  43.2k|#define regs (mrb->c->ci->stack)
  ------------------
                      mrb_ensure_hash_type(mrb, regs[a+(n==CALL_MAXARGS?1:n)+1]);
  ------------------
  |  |   84|  43.2k|#define CALL_MAXARGS 15
  ------------------
  |  Branch (1775:43): [True: 43.2k, False: 0]
  ------------------
 1776|  43.2k|      }
 1777|   676k|      else if (nk > 0) {  /* pack keyword arguments */
  ------------------
  |  Branch (1777:16): [True: 0, False: 676k]
  ------------------
 1778|      0|        mrb_int kidx = a+(n==CALL_MAXARGS?1:n)+1;
  ------------------
  |  |   84|      0|#define CALL_MAXARGS 15
  ------------------
  |  Branch (1778:27): [True: 0, False: 0]
  ------------------
 1779|      0|        mrb_value kdict = hash_new_from_regs(mrb, nk, kidx);
 1780|      0|        regs[kidx] = kdict;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1781|      0|        nk = CALL_MAXARGS;
  ------------------
  |  |   84|      0|#define CALL_MAXARGS 15
  ------------------
 1782|      0|        c = n | (nk<<4);
 1783|      0|        new_bidx = a+mrb_bidx(n, nk);
 1784|      0|      }
 1785|       |
 1786|   719k|      mrb_assert(bidx < irep->nregs);
  ------------------
  |  |   68|   719k|#define mrb_assert(p) ((void)0)
  ------------------
 1787|   719k|      if (insn == OP_SEND) {
  ------------------
  |  Branch (1787:11): [True: 586k, False: 133k]
  ------------------
 1788|       |        /* clear block argument */
 1789|   586k|        SET_NIL_VALUE(regs[new_bidx]);
  ------------------
  |  |  210|   586k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 1790|   586k|        SET_NIL_VALUE(blk);
  ------------------
  |  |  210|   586k|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 1791|   586k|      }
 1792|   133k|      else {
 1793|   133k|        blk = ensure_block(mrb, regs[bidx]);
  ------------------
  |  | 1335|   133k|#define regs (mrb->c->ci->stack)
  ------------------
 1794|   133k|        regs[new_bidx] = blk;
  ------------------
  |  | 1335|   133k|#define regs (mrb->c->ci->stack)
  ------------------
 1795|   133k|      }
 1796|       |
 1797|   719k|      ci = cipush(mrb, a, CINFO_DIRECT, NULL, NULL, BLK_PTR(blk), 0, c);
  ------------------
  |  |  336|   719k|#define CINFO_DIRECT  2 // called method from C
  ------------------
                    ci = cipush(mrb, a, CINFO_DIRECT, NULL, NULL, BLK_PTR(blk), 0, c);
  ------------------
  |  |  339|   719k|#define BLK_PTR(b) ((mrb_proc_p(b)) ? mrb_proc_ptr(b) : NULL)
  |  |  ------------------
  |  |  |  |  197|   719k|#define mrb_proc_p(o) WORDBOX_OBJ_TYPE_P(o, PROC)
  |  |  |  |  ------------------
  |  |  |  |  |  |   78|   719k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  148|  1.43M|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   71|  1.43M|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 719k]
  |  |  |  |  |  |  |  |  |  Branch (148:63): [True: 694k, False: 24.4k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (78:27): [True: 24.4k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define BLK_PTR(b) ((mrb_proc_p(b)) ? mrb_proc_ptr(b) : NULL)
  |  |  ------------------
  |  |  |  |   90|  24.4k|#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  150|  24.4k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1798|   719k|      recv = regs[0];
  ------------------
  |  | 1335|   719k|#define regs (mrb->c->ci->stack)
  ------------------
 1799|   719k|      ci->u.target_class = (insn == OP_SUPER) ? CI_TARGET_CLASS(ci - 1)->super : mrb_class(mrb, recv);
  ------------------
  |  |  267|      0|#define CI_TARGET_CLASS(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env->c : (ci)->u.target_class)
  |  |  ------------------
  |  |  |  Branch (267:31): [True: 0, False: 0]
  |  |  |  Branch (267:46): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1799:28): [True: 0, False: 719k]
  ------------------
 1800|   719k|      m = mrb_vm_find_method(mrb, ci->u.target_class, &ci->u.target_class, mid);
 1801|   719k|      if (MRB_METHOD_UNDEF_P(m)) {
  ------------------
  |  |  115|   719k|#define MRB_METHOD_UNDEF_P(m) ((m)==0)
  |  |  ------------------
  |  |  |  Branch (115:31): [True: 126, False: 719k]
  |  |  ------------------
  ------------------
 1802|    126|        m = prepare_missing(mrb, ci, recv, mid, blk, (insn == OP_SUPER));
 1803|    126|      }
 1804|   719k|      else {
 1805|   719k|        ci->mid = mid;
 1806|   719k|      }
 1807|   719k|      ci->cci = CINFO_NONE;
  ------------------
  |  |  334|   719k|#define CINFO_NONE    0 // called method from mruby VM (without C functions)
  ------------------
 1808|       |
 1809|   719k|      if (MRB_METHOD_CFUNC_P(m)) {
  ------------------
  |  |  131|   719k|#define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |  107|   719k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|   719k|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (107:30): [True: 443k, False: 275k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   54|   443k|#  define TRUE 1
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |  114|   275k|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (114:28): [True: 275k, False: 126]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   65|   275k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   275k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
  |  |  ------------------
  |  |  |  |   51|    126|#  define FALSE 0
  |  |  ------------------
  |  |  |  Branch (131:31): [True: 443k, False: 275k]
  |  |  ------------------
  ------------------
 1810|   443k|        if (MRB_METHOD_PROC_P(m)) {
  ------------------
  |  |  113|   443k|#define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
  |  |  ------------------
  |  |  |  |  107|   443k|#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
  |  |  |  |  ------------------
  |  |  |  |  |  |  102|   443k|#define MRB_METHOD_FUNC_FL 1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (113:30): [True: 0, False: 443k]
  |  |  ------------------
  ------------------
 1811|      0|          struct RProc *p = MRB_METHOD_PROC(m);
  ------------------
  |  |  114|      0|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  ------------------
 1812|      0|          CI_PROC_SET(ci, p);
  ------------------
  |  |  256|      0|#define CI_PROC_SET(ci, p) do {\
  |  |  257|      0|  ci->proc = p;\
  |  |  258|      0|  ci->pc = (p && !MRB_PROC_CFUNC_P(p)) ? p->body.irep->iseq : NULL;\
  |  |  ------------------
  |  |  |  |   65|      0|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (258:13): [True: 0, False: 0]
  |  |  |  Branch (258:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  259|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1813|      0|          recv = p->body.func(mrb, recv);
 1814|      0|        }
 1815|   443k|        else {
 1816|   443k|          if (MRB_METHOD_NOARG_P(m)) {
  ------------------
  |  |  108|   443k|#define MRB_METHOD_NOARG_P(m) ((((uintptr_t)(m))&MRB_METHOD_NOARG_FL)?1:0)
  |  |  ------------------
  |  |  |  |  103|   443k|#define MRB_METHOD_NOARG_FL 2
  |  |  ------------------
  |  |  |  Branch (108:31): [True: 136k, False: 307k]
  |  |  |  Branch (108:32): [True: 136k, False: 307k]
  |  |  ------------------
  ------------------
 1817|   136k|            check_method_noarg(mrb, ci);
 1818|   136k|          }
 1819|   443k|          recv = MRB_METHOD_FUNC(m)(mrb, recv);
  ------------------
  |  |  110|   443k|#define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)>>2))
  ------------------
 1820|   443k|        }
 1821|   443k|        mrb_gc_arena_shrink(mrb, ai);
 1822|   443k|        if (mrb->exc) goto L_RAISE;
  ------------------
  |  Branch (1822:13): [True: 0, False: 443k]
  ------------------
 1823|   443k|        ci = mrb->c->ci;
 1824|   443k|        if (!ci->u.target_class) { /* return from context modifying method (resume/yield) */
  ------------------
  |  Branch (1824:13): [True: 1.74k, False: 442k]
  ------------------
 1825|  1.74k|          if (ci->cci == CINFO_RESUMED) {
  ------------------
  |  |  337|  1.74k|#define CINFO_RESUMED 3 // resumed by `Fiber.yield` (probably the main call is `mrb_fiber_resume()`)
  ------------------
  |  Branch (1825:15): [True: 0, False: 1.74k]
  ------------------
 1826|      0|            mrb->jmp = prev_jmp;
 1827|      0|            return recv;
 1828|      0|          }
 1829|  1.74k|          else {
 1830|  1.74k|            mrb_assert(!MRB_PROC_CFUNC_P(ci[-1].proc));
  ------------------
  |  |   68|  1.74k|#define mrb_assert(p) ((void)0)
  ------------------
 1831|  1.74k|            proc = ci[-1].proc;
 1832|  1.74k|            irep = proc->body.irep;
 1833|  1.74k|            pool = irep->pool;
 1834|  1.74k|            syms = irep->syms;
 1835|  1.74k|          }
 1836|  1.74k|        }
 1837|   443k|        ci->stack[0] = recv;
 1838|       |        /* pop stackpos */
 1839|   443k|        ci = cipop(mrb);
 1840|   443k|        pc = ci->pc;
 1841|   443k|      }
 1842|   275k|      else {
 1843|       |        /* setup environment for calling method */
 1844|   275k|        proc = MRB_METHOD_PROC(m);
  ------------------
  |  |  114|   275k|#define MRB_METHOD_PROC(m) ((struct RProc*)(m))
  ------------------
 1845|   275k|        CI_PROC_SET(ci, proc);
  ------------------
  |  |  256|   275k|#define CI_PROC_SET(ci, p) do {\
  |  |  257|   275k|  ci->proc = p;\
  |  |  258|   275k|  ci->pc = (p && !MRB_PROC_CFUNC_P(p)) ? p->body.irep->iseq : NULL;\
  |  |  ------------------
  |  |  |  |   65|   275k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   275k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (258:13): [True: 275k, False: 126]
  |  |  |  Branch (258:18): [True: 275k, False: 0]
  |  |  ------------------
  |  |  259|   275k|} while (0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1846|   275k|        irep = proc->body.irep;
 1847|   275k|        pool = irep->pool;
 1848|   275k|        syms = irep->syms;
 1849|   275k|        stack_extend(mrb, (irep->nregs < 4) ? 4 : irep->nregs);
  ------------------
  |  Branch (1849:27): [True: 22.6k, False: 252k]
  ------------------
 1850|   275k|        pc = irep->iseq;
 1851|   275k|      }
 1852|   719k|    }
 1853|   719k|    JUMP;
  ------------------
  |  | 1282|   719k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|   719k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|   719k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|   719k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 719k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1854|       |
 1855|   719k|    CASE(OP_CALL, Z) {
  ------------------
  |  | 1280|   719k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1856|  45.3k|      mrb_callinfo *ci = mrb->c->ci;
 1857|  45.3k|      mrb_value recv = ci->stack[0];
 1858|  45.3k|      struct RProc *m = mrb_proc_ptr(recv);
  ------------------
  |  |   90|  22.6k|#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  22.6k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1859|       |
 1860|       |      /* replace callinfo */
 1861|  45.3k|      ci->u.target_class = MRB_PROC_TARGET_CLASS(m);
  ------------------
  |  |   74|  22.6k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|  22.6k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  22.6k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 22.6k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1862|  45.3k|      CI_PROC_SET(ci, m);
  ------------------
  |  |  256|  22.6k|#define CI_PROC_SET(ci, p) do {\
  |  |  257|  22.6k|  ci->proc = p;\
  |  |  258|  22.6k|  ci->pc = (p && !MRB_PROC_CFUNC_P(p)) ? p->body.irep->iseq : NULL;\
  |  |  ------------------
  |  |  |  |   65|  22.6k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  22.6k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (258:13): [True: 22.6k, False: 0]
  |  |  |  Branch (258:18): [True: 22.6k, False: 0]
  |  |  ------------------
  |  |  259|  22.6k|} while (0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1863|  45.3k|      if (MRB_PROC_ENV_P(m)) {
  ------------------
  |  |   72|  22.6k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|  22.6k|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 22.6k, False: 0]
  |  |  ------------------
  ------------------
 1864|  22.6k|        ci->mid = MRB_PROC_ENV(m)->mid;
  ------------------
  |  |   73|  22.6k|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|  22.6k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  22.6k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 22.6k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1865|  22.6k|      }
 1866|       |
 1867|       |      /* prepare stack */
 1868|  45.3k|      if (MRB_PROC_CFUNC_P(m)) {
  ------------------
  |  |   65|  22.6k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|  22.6k|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  |  |  |  Branch (65:29): [True: 0, False: 22.6k]
  |  |  ------------------
  ------------------
 1869|      0|        recv = MRB_PROC_CFUNC(m)(mrb, recv);
  ------------------
  |  |   66|      0|#define MRB_PROC_CFUNC(p) (p)->body.func
  ------------------
 1870|      0|        mrb_gc_arena_shrink(mrb, ai);
 1871|      0|        if (mrb->exc) goto L_RAISE;
  ------------------
  |  Branch (1871:13): [True: 0, False: 0]
  ------------------
 1872|       |        /* pop stackpos */
 1873|      0|        ci = cipop(mrb);
 1874|      0|        pc = ci->pc;
 1875|      0|        ci[1].stack[0] = recv;
 1876|      0|        irep = mrb->c->ci->proc->body.irep;
 1877|      0|      }
 1878|  22.6k|      else {
 1879|       |        /* setup environment for calling method */
 1880|  22.6k|        proc = m;
 1881|  22.6k|        irep = m->body.irep;
 1882|  22.6k|        if (!irep) {
  ------------------
  |  Branch (1882:13): [True: 0, False: 22.6k]
  ------------------
 1883|      0|          mrb->c->ci->stack[0] = mrb_nil_value();
 1884|      0|          a = 0;
 1885|      0|          c = OP_R_NORMAL;
  ------------------
  |  |   22|      0|#define OP_R_NORMAL 0
  ------------------
 1886|      0|          goto L_OP_RETURN_BODY;
 1887|      0|        }
 1888|  22.6k|        mrb_int nargs = ci_bidx(ci)+1;
 1889|  22.6k|        if (nargs < irep->nregs) {
  ------------------
  |  Branch (1889:13): [True: 22.6k, False: 0]
  ------------------
 1890|  22.6k|          stack_extend(mrb, irep->nregs);
 1891|  22.6k|          stack_clear(regs+nargs, irep->nregs-nargs);
  ------------------
  |  | 1335|  22.6k|#define regs (mrb->c->ci->stack)
  ------------------
 1892|  22.6k|        }
 1893|  22.6k|        if (MRB_PROC_ENV_P(m)) {
  ------------------
  |  |   72|  22.6k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|  22.6k|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 22.6k, False: 0]
  |  |  ------------------
  ------------------
 1894|  22.6k|          regs[0] = MRB_PROC_ENV(m)->stack[0];
  ------------------
  |  | 1335|  22.6k|#define regs (mrb->c->ci->stack)
  ------------------
                        regs[0] = MRB_PROC_ENV(m)->stack[0];
  ------------------
  |  |   73|  22.6k|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|  22.6k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  22.6k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 22.6k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1895|  22.6k|        }
 1896|  22.6k|        pc = irep->iseq;
 1897|  22.6k|      }
 1898|  22.6k|      pool = irep->pool;
 1899|  22.6k|      syms = irep->syms;
 1900|  22.6k|      JUMP;
  ------------------
  |  | 1282|  22.6k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|  22.6k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  22.6k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  22.6k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 22.6k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1901|  22.6k|    }
 1902|       |
 1903|  22.6k|    CASE(OP_SUPER, BB) {
  ------------------
  |  | 1280|  22.6k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1904|      0|      mrb_callinfo *ci = mrb->c->ci;
 1905|      0|      mrb_value recv;
 1906|      0|      const struct RProc *p = ci->proc;
 1907|      0|      struct RClass* target_class = CI_TARGET_CLASS(ci);
  ------------------
  |  |  267|      0|#define CI_TARGET_CLASS(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env->c : (ci)->u.target_class)
  |  |  ------------------
  |  |  |  Branch (267:31): [True: 0, False: 0]
  |  |  |  Branch (267:46): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1908|       |
 1909|      0|      mid = ci->mid;
 1910|      0|      if (MRB_PROC_ENV_P(p) && p->e.env->mid && p->e.env->mid != mid) { /* alias support */
  ------------------
  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1910:32): [True: 0, False: 0]
  |  Branch (1910:49): [True: 0, False: 0]
  ------------------
 1911|      0|        mid = p->e.env->mid;    /* restore old mid */
 1912|      0|      }
 1913|       |
 1914|      0|      if (mid == 0 || !target_class) {
  ------------------
  |  Branch (1914:11): [True: 0, False: 0]
  |  Branch (1914:23): [True: 0, False: 0]
  ------------------
 1915|      0|        RAISE_LIT(mrb, E_NOMETHOD_ERROR, "super called outside of method");
  ------------------
  |  | 1163|      0|#define RAISE_LIT(mrb, c, str)          RAISE_EXC(mrb, mrb_exc_new_lit(mrb, c, str))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1916|      0|      }
 1917|      0|      if ((target_class->flags & MRB_FL_CLASS_IS_PREPENDED) || target_class->tt == MRB_TT_MODULE) {
  ------------------
  |  |   63|      0|#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
  ------------------
  |  Branch (1917:11): [True: 0, False: 0]
  |  Branch (1917:64): [True: 0, False: 0]
  ------------------
 1918|      0|        goto super_typeerror;
 1919|      0|      }
 1920|      0|      recv = regs[0];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1921|      0|      if (!mrb_obj_is_kind_of(mrb, recv, target_class)) {
  ------------------
  |  Branch (1921:11): [True: 0, False: 0]
  ------------------
 1922|      0|      super_typeerror:
 1923|      0|        RAISE_LIT(mrb, E_TYPE_ERROR, "self has wrong type to call super in this context");
  ------------------
  |  | 1163|      0|#define RAISE_LIT(mrb, c, str)          RAISE_EXC(mrb, mrb_exc_new_lit(mrb, c, str))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1924|      0|      }
 1925|       |
 1926|      0|      c = b; // arg info
 1927|      0|      regs[a] = recv;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1928|      0|      goto L_SENDB_SYM;
 1929|      0|    }
 1930|       |
 1931|      0|    CASE(OP_ARGARY, BS) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1932|      0|      mrb_int m1 = (b>>11)&0x3f;
 1933|      0|      mrb_int r  = (b>>10)&0x1;
 1934|      0|      mrb_int m2 = (b>>5)&0x1f;
 1935|      0|      mrb_int kd = (b>>4)&0x1;
 1936|      0|      mrb_int lv = (b>>0)&0xf;
 1937|      0|      mrb_value *stack;
 1938|       |
 1939|      0|      if (mrb->c->ci->mid == 0 || CI_TARGET_CLASS(mrb->c->ci) == NULL) {
  ------------------
  |  |  267|      0|#define CI_TARGET_CLASS(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env->c : (ci)->u.target_class)
  |  |  ------------------
  |  |  |  Branch (267:31): [True: 0, False: 0]
  |  |  |  Branch (267:46): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1939:11): [True: 0, False: 0]
  |  Branch (1939:35): [True: 0, False: 0]
  ------------------
 1940|      0|      L_NOSUPER:
 1941|      0|        RAISE_LIT(mrb, E_NOMETHOD_ERROR, "super called outside of method");
  ------------------
  |  | 1163|      0|#define RAISE_LIT(mrb, c, str)          RAISE_EXC(mrb, mrb_exc_new_lit(mrb, c, str))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1942|      0|      }
 1943|      0|      if (lv == 0) stack = regs + 1;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
  |  Branch (1943:11): [True: 0, False: 0]
  ------------------
 1944|      0|      else {
 1945|      0|        struct REnv *e = uvenv(mrb, lv-1);
 1946|      0|        if (!e) goto L_NOSUPER;
  ------------------
  |  Branch (1946:13): [True: 0, False: 0]
  ------------------
 1947|      0|        if (MRB_ENV_LEN(e) <= m1+r+m2+1)
  ------------------
  |  |   27|      0|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  |  Branch (1947:13): [True: 0, False: 0]
  ------------------
 1948|      0|          goto L_NOSUPER;
 1949|      0|        stack = e->stack + 1;
 1950|      0|      }
 1951|      0|      if (r == 0) {
  ------------------
  |  Branch (1951:11): [True: 0, False: 0]
  ------------------
 1952|      0|        regs[a] = mrb_ary_new_from_values(mrb, m1+m2, stack);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1953|      0|      }
 1954|      0|      else {
 1955|      0|        mrb_value *pp = NULL;
 1956|      0|        struct RArray *rest;
 1957|      0|        mrb_int len = 0;
 1958|       |
 1959|      0|        if (mrb_array_p(stack[m1])) {
  ------------------
  |  |  186|      0|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1960|      0|          struct RArray *ary = mrb_ary_ptr(stack[m1]);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1961|       |
 1962|      0|          pp = ARY_PTR(ary);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 1963|      0|          len = ARY_LEN(ary);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1964|      0|        }
 1965|      0|        regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1966|      0|        rest = mrb_ary_ptr(regs[a]);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 1967|      0|        if (m1 > 0) {
  ------------------
  |  Branch (1967:13): [True: 0, False: 0]
  ------------------
 1968|      0|          stack_copy(ARY_PTR(rest), stack, m1);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 1969|      0|        }
 1970|      0|        if (len > 0) {
  ------------------
  |  Branch (1970:13): [True: 0, False: 0]
  ------------------
 1971|      0|          stack_copy(ARY_PTR(rest)+m1, pp, len);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 1972|      0|        }
 1973|      0|        if (m2 > 0) {
  ------------------
  |  Branch (1973:13): [True: 0, False: 0]
  ------------------
 1974|      0|          stack_copy(ARY_PTR(rest)+m1+len, stack+m1+1, m2);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 1975|      0|        }
 1976|      0|        ARY_SET_LEN(rest, m1+len+m2);
  ------------------
  |  |   74|      0|#define ARY_SET_LEN(a,n) do {\
  |  |   75|      0|  if (ARY_EMBED_P(a)) {\
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
  |  |  ------------------
  |  |  |  |   68|      0|#define mrb_assert(p) ((void)0)
  |  |  ------------------
  |  |   77|      0|    ARY_SET_EMBED_LEN(a,n);\
  |  |  ------------------
  |  |  |  |   66|      0|#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|  }\
  |  |   79|      0|  else\
  |  |   80|      0|    (a)->as.heap.len = (n);\
  |  |   81|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (81:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1977|      0|      }
 1978|      0|      if (kd) {
  ------------------
  |  Branch (1978:11): [True: 0, False: 0]
  ------------------
 1979|      0|        regs[a+1] = stack[m1+r+m2];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1980|      0|        regs[a+2] = stack[m1+r+m2+1];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1981|      0|      }
 1982|      0|      else {
 1983|      0|        regs[a+1] = stack[m1+r+m2];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 1984|      0|      }
 1985|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 1986|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1987|      0|    }
 1988|       |
 1989|   554k|    CASE(OP_ENTER, W) {
  ------------------
  |  | 1280|   277k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 1990|   554k|      mrb_callinfo *ci = mrb->c->ci;
 1991|   554k|      mrb_int argc = ci->n;
 1992|   554k|      mrb_value *argv = regs+1;
  ------------------
  |  | 1335|   277k|#define regs (mrb->c->ci->stack)
  ------------------
 1993|       |
 1994|   554k|      mrb_int m1 = MRB_ASPEC_REQ(a);
  ------------------
  |  |   56|   277k|#define MRB_ASPEC_REQ(a)          (((a) >> 18) & 0x1f)
  ------------------
 1995|       |
 1996|       |       /* no other args */
 1997|   554k|      if ((a & ~0x7c0001) == 0 && argc < 15 && MRB_PROC_STRICT_P(proc)) {
  ------------------
  |  |   68|   100k|#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
  |  |  ------------------
  |  |  |  |   67|   100k|#define MRB_PROC_STRICT 256
  |  |  ------------------
  |  |  |  Branch (68:30): [True: 76.3k, False: 24.4k]
  |  |  ------------------
  ------------------
  |  Branch (1997:11): [True: 100k, False: 176k]
  |  Branch (1997:35): [True: 100k, False: 0]
  ------------------
 1998|  76.3k|        if (argc+(ci->nk==15) != m1) { /* count kdict too */
  ------------------
  |  Branch (1998:13): [True: 43, False: 76.2k]
  ------------------
 1999|     43|          argnum_error(mrb, m1);
 2000|     43|          goto L_RAISE;
 2001|     43|        }
 2002|       |        /* clear local (but non-argument) variables */
 2003|  76.2k|        mrb_int pos = m1+2;     /* self+m1+blk */
 2004|  76.2k|        if (irep->nlocals-pos  > 0) {
  ------------------
  |  Branch (2004:13): [True: 71.6k, False: 4.64k]
  ------------------
 2005|  71.6k|          stack_clear(&regs[pos], irep->nlocals-pos);
  ------------------
  |  | 1335|  71.6k|#define regs (mrb->c->ci->stack)
  ------------------
 2006|  71.6k|        }
 2007|  76.2k|        NEXT;
  ------------------
  |  | 1281|  76.2k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  76.2k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  76.2k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 76.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2008|  76.2k|      }
 2009|       |
 2010|   277k|      mrb_int o  = MRB_ASPEC_OPT(a);
  ------------------
  |  |   57|   277k|#define MRB_ASPEC_OPT(a)          (((a) >> 13) & 0x1f)
  ------------------
 2011|   277k|      mrb_int r  = MRB_ASPEC_REST(a);
  ------------------
  |  |   58|   277k|#define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
  ------------------
 2012|   277k|      mrb_int m2 = MRB_ASPEC_POST(a);
  ------------------
  |  |   59|   277k|#define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
  ------------------
 2013|   277k|      mrb_int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
  ------------------
  |  |   60|   277k|#define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
  ------------------
                    mrb_int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
  ------------------
  |  |   61|   200k|#define MRB_ASPEC_KDICT(a)        (((a) >> 1) & 0x1)
  |  |  ------------------
  |  |  |  Branch (61:35): [True: 68.0k, False: 132k]
  |  |  ------------------
  ------------------
  |  Branch (2013:21): [True: 76.2k, False: 200k]
  ------------------
 2014|       |      /* unused
 2015|       |      int b  = MRB_ASPEC_BLOCK(a);
 2016|       |      */
 2017|   277k|      mrb_int const len = m1 + o + r + m2;
 2018|       |
 2019|   277k|      mrb_value * const argv0 = argv;
 2020|   277k|      mrb_value blk = regs[ci_bidx(ci)];
  ------------------
  |  | 1335|   277k|#define regs (mrb->c->ci->stack)
  ------------------
 2021|   277k|      mrb_value kdict = mrb_nil_value();
 2022|       |
 2023|       |      /* keyword arguments */
 2024|   277k|      if (ci->nk == 15) {
  ------------------
  |  Branch (2024:11): [True: 36.2k, False: 240k]
  ------------------
 2025|  36.2k|        kdict = regs[mrb_ci_kidx(ci)];
  ------------------
  |  | 1335|  36.2k|#define regs (mrb->c->ci->stack)
  ------------------
 2026|  36.2k|      }
 2027|   277k|      if (!kd) {
  ------------------
  |  Branch (2027:11): [True: 132k, False: 144k]
  ------------------
 2028|   132k|        if (!mrb_nil_p(kdict) && mrb_hash_size(mrb, kdict) > 0) {
  ------------------
  |  |  174|   265k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
  |  Branch (2028:13): [True: 11.3k, False: 121k]
  |  Branch (2028:34): [True: 0, False: 11.3k]
  ------------------
 2029|      0|          if (argc < 14) {
  ------------------
  |  Branch (2029:15): [True: 0, False: 0]
  ------------------
 2030|      0|            ci->n++;
 2031|      0|            argc++;    /* include kdict in normal arguments */
 2032|      0|          }
 2033|      0|          else if (argc == 14) {
  ------------------
  |  Branch (2033:20): [True: 0, False: 0]
  ------------------
 2034|       |            /* pack arguments and kdict */
 2035|      0|            regs[1] = ary_new_from_regs(mrb, argc+1, 1);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2036|      0|            argc = ci->n = 15;
 2037|      0|          }
 2038|      0|          else {/* argc == 15 */
 2039|       |            /* push kdict to packed arguments */
 2040|      0|            mrb_ary_push(mrb, regs[1], kdict);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2041|      0|          }
 2042|      0|        }
 2043|   132k|        kdict = mrb_nil_value();
 2044|   132k|        ci->nk = 0;
 2045|   132k|      }
 2046|   144k|      else if (MRB_ASPEC_KEY(a) > 0 && !mrb_nil_p(kdict)) {
  ------------------
  |  |   60|   144k|#define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
  ------------------
                    else if (MRB_ASPEC_KEY(a) > 0 && !mrb_nil_p(kdict)) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
  |  Branch (2046:16): [True: 0, False: 144k]
  |  Branch (2046:40): [True: 0, False: 0]
  ------------------
 2047|      0|        kdict = mrb_hash_dup(mrb, kdict);
 2048|      0|      }
 2049|       |
 2050|       |      /* arguments is passed with Array */
 2051|   277k|      if (argc == 15) {
  ------------------
  |  Branch (2051:11): [True: 66.3k, False: 210k]
  ------------------
 2052|  66.3k|        struct RArray *ary = mrb_ary_ptr(regs[1]);
  ------------------
  |  |   51|  66.3k|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  66.3k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2053|  66.3k|        argv = ARY_PTR(ary);
  ------------------
  |  |   71|  66.3k|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|  66.3k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  66.3k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 66.3k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|  66.3k|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 2054|  66.3k|        argc = (int)ARY_LEN(ary);
  ------------------
  |  |   70|  66.3k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|  66.3k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  66.3k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 66.3k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|  66.3k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|  66.3k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2055|  66.3k|        mrb_gc_protect(mrb, regs[1]);
  ------------------
  |  | 1335|  66.3k|#define regs (mrb->c->ci->stack)
  ------------------
 2056|  66.3k|        if (kd && !mrb_nil_p(kdict)) mrb_gc_protect(mrb, kdict);
  ------------------
  |  |  174|  54.9k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
  |  Branch (2056:13): [True: 54.9k, False: 11.3k]
  |  Branch (2056:19): [True: 24.8k, False: 30.1k]
  ------------------
 2057|  66.3k|      }
 2058|       |
 2059|       |      /* strict argument check */
 2060|   277k|      if (ci->proc && MRB_PROC_STRICT_P(ci->proc)) {
  ------------------
  |  |   68|   200k|#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
  |  |  ------------------
  |  |  |  |   67|   200k|#define MRB_PROC_STRICT 256
  |  |  ------------------
  |  |  |  Branch (68:30): [True: 176k, False: 24.4k]
  |  |  ------------------
  ------------------
  |  Branch (2060:11): [True: 200k, False: 76.2k]
  ------------------
 2061|   176k|        if (argc < m1 + m2 || (r == 0 && argc > len)) {
  ------------------
  |  Branch (2061:13): [True: 0, False: 176k]
  |  Branch (2061:32): [True: 40.6k, False: 135k]
  |  Branch (2061:42): [True: 0, False: 40.6k]
  ------------------
 2062|      0|          argnum_error(mrb, m1+m2);
 2063|      0|          goto L_RAISE;
 2064|      0|        }
 2065|   176k|      }
 2066|       |      /* extract first argument array to arguments */
 2067|   100k|      else if (len > 1 && argc == 1 && mrb_array_p(argv[0])) {
  ------------------
  |  |  186|      0|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (2067:16): [True: 0, False: 100k]
  |  Branch (2067:27): [True: 0, False: 0]
  ------------------
 2068|      0|        mrb_gc_protect(mrb, argv[0]);
 2069|      0|        argc = (int)RARRAY_LEN(argv[0]);
  ------------------
  |  |   72|      0|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2070|      0|        argv = RARRAY_PTR(argv[0]);
  ------------------
  |  |   73|      0|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2071|      0|      }
 2072|       |
 2073|       |      /* rest arguments */
 2074|   277k|      mrb_value rest = mrb_nil_value();
 2075|   277k|      if (argc < len) {
  ------------------
  |  Branch (2075:11): [True: 21.2k, False: 255k]
  ------------------
 2076|  21.2k|        mrb_int mlen = m2;
 2077|  21.2k|        if (argc < m1+m2) {
  ------------------
  |  Branch (2077:13): [True: 0, False: 21.2k]
  ------------------
 2078|      0|          mlen = m1 < argc ? argc - m1 : 0;
  ------------------
  |  Branch (2078:18): [True: 0, False: 0]
  ------------------
 2079|      0|        }
 2080|       |
 2081|       |        /* copy mandatory and optional arguments */
 2082|  21.2k|        if (argv0 != argv && argv) {
  ------------------
  |  Branch (2082:13): [True: 11.3k, False: 9.94k]
  |  Branch (2082:30): [True: 11.3k, False: 0]
  ------------------
 2083|  11.3k|          value_move(&regs[1], argv, argc-mlen); /* m1 + o */
  ------------------
  |  | 1335|  11.3k|#define regs (mrb->c->ci->stack)
  ------------------
 2084|  11.3k|        }
 2085|  21.2k|        if (argc < m1) {
  ------------------
  |  Branch (2085:13): [True: 0, False: 21.2k]
  ------------------
 2086|      0|          stack_clear(&regs[argc+1], m1-argc);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2087|      0|        }
 2088|       |        /* copy post mandatory arguments */
 2089|  21.2k|        if (mlen) {
  ------------------
  |  Branch (2089:13): [True: 0, False: 21.2k]
  ------------------
 2090|      0|          value_move(&regs[len-m2+1], &argv[argc-mlen], mlen);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2091|      0|        }
 2092|  21.2k|        if (mlen < m2) {
  ------------------
  |  Branch (2092:13): [True: 0, False: 21.2k]
  ------------------
 2093|      0|          stack_clear(&regs[len-m2+mlen+1], m2-mlen);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2094|      0|        }
 2095|       |        /* initialize rest arguments with empty Array */
 2096|  21.2k|        if (r) {
  ------------------
  |  Branch (2096:13): [True: 7.89k, False: 13.3k]
  ------------------
 2097|  7.89k|          rest = mrb_ary_new_capa(mrb, 0);
 2098|  7.89k|          regs[m1+o+1] = rest;
  ------------------
  |  | 1335|  7.89k|#define regs (mrb->c->ci->stack)
  ------------------
 2099|  7.89k|        }
 2100|       |        /* skip initializer of passed arguments */
 2101|  21.2k|        if (o > 0 && argc > m1+m2)
  ------------------
  |  Branch (2101:13): [True: 13.3k, False: 7.89k]
  |  Branch (2101:22): [True: 12.1k, False: 1.25k]
  ------------------
 2102|  12.1k|          pc += (argc - m1 - m2)*3;
 2103|  21.2k|      }
 2104|   255k|      else {
 2105|   255k|        mrb_int rnum = 0;
 2106|   255k|        if (argv0 != argv) {
  ------------------
  |  Branch (2106:13): [True: 54.9k, False: 200k]
  ------------------
 2107|  54.9k|          mrb_gc_protect(mrb, blk);
 2108|  54.9k|          mrb_gc_protect(mrb, kdict);
 2109|  54.9k|          value_move(&regs[1], argv, m1+o);
  ------------------
  |  | 1335|  54.9k|#define regs (mrb->c->ci->stack)
  ------------------
 2110|  54.9k|        }
 2111|   255k|        if (r) {
  ------------------
  |  Branch (2111:13): [True: 127k, False: 127k]
  ------------------
 2112|   127k|          rnum = argc-m1-o-m2;
 2113|   127k|          rest = mrb_ary_new_from_values(mrb, rnum, argv+m1+o);
 2114|   127k|          regs[m1+o+1] = rest;
  ------------------
  |  | 1335|   127k|#define regs (mrb->c->ci->stack)
  ------------------
 2115|   127k|        }
 2116|   255k|        if (m2 > 0 && argc-m2 > m1) {
  ------------------
  |  Branch (2116:13): [True: 0, False: 255k]
  |  Branch (2116:23): [True: 0, False: 0]
  ------------------
 2117|      0|          value_move(&regs[m1+o+r+1], &argv[m1+o+rnum], m2);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2118|      0|        }
 2119|   255k|        pc += o*3;
 2120|   255k|      }
 2121|       |
 2122|       |      /* need to be update blk first to protect blk from GC */
 2123|   277k|      mrb_int const kw_pos = len + kd;    /* where kwhash should be */
 2124|   277k|      mrb_int const blk_pos = kw_pos + 1; /* where block should be */
 2125|   277k|      regs[blk_pos] = blk;                /* move block */
  ------------------
  |  | 1335|   277k|#define regs (mrb->c->ci->stack)
  ------------------
 2126|   277k|      if (kd) {
  ------------------
  |  Branch (2126:11): [True: 68.0k, False: 208k]
  ------------------
 2127|  68.0k|        if (mrb_nil_p(kdict)) {
  ------------------
  |  |  174|  68.0k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 43.2k, False: 24.8k]
  |  |  ------------------
  ------------------
 2128|  43.2k|          kdict = mrb_hash_new_capa(mrb, 0);
 2129|  43.2k|        }
 2130|  68.0k|        regs[kw_pos] = kdict;             /* set kwhash */
  ------------------
  |  | 1335|  68.0k|#define regs (mrb->c->ci->stack)
  ------------------
 2131|  68.0k|        ci->nk = 15;
 2132|  68.0k|      }
 2133|       |
 2134|       |      /* format arguments for generated code */
 2135|   277k|      mrb->c->ci->n = (uint8_t)len;
 2136|       |
 2137|       |      /* clear local (but non-argument) variables */
 2138|   277k|      if (irep->nlocals-blk_pos-1 > 0) {
  ------------------
  |  Branch (2138:11): [True: 49.1k, False: 227k]
  ------------------
 2139|  49.1k|        stack_clear(&regs[blk_pos+1], irep->nlocals-blk_pos-1);
  ------------------
  |  | 1335|  49.1k|#define regs (mrb->c->ci->stack)
  ------------------
 2140|  49.1k|      }
 2141|   277k|      JUMP;
  ------------------
  |  | 1282|   277k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|   277k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|   277k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|   277k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 277k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2142|   277k|    }
 2143|       |
 2144|   277k|    CASE(OP_KARG, BB) {
  ------------------
  |  | 1280|   277k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2145|      0|      mrb_value k = mrb_symbol_value(syms[b]);
 2146|      0|      mrb_int kidx = mrb_ci_kidx(mrb->c->ci);
 2147|      0|      mrb_value kdict, v;
 2148|       |
 2149|      0|      if (kidx < 0 || !mrb_hash_p(kdict=regs[kidx]) || !mrb_hash_key_p(mrb, kdict, k)) {
  ------------------
  |  |  188|      0|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (2149:11): [True: 0, False: 0]
  |  Branch (2149:56): [True: 0, False: 0]
  ------------------
 2150|      0|        RAISE_FORMAT(mrb, E_ARGUMENT_ERROR, "missing keyword: %v", k);
  ------------------
  |  | 1164|      0|#define RAISE_FORMAT(mrb, c, fmt, ...)  RAISE_EXC(mrb, mrb_exc_new_str(mrb, c, mrb_format(mrb, fmt, __VA_ARGS__)))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2151|      0|      }
 2152|      0|      v = mrb_hash_get(mrb, kdict, k);
 2153|      0|      regs[a] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2154|      0|      mrb_hash_delete_key(mrb, kdict, k);
 2155|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2156|      0|    }
 2157|       |
 2158|      0|    CASE(OP_KEY_P, BB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2159|      0|      mrb_value k = mrb_symbol_value(syms[b]);
 2160|      0|      mrb_int kidx = mrb_ci_kidx(mrb->c->ci);
 2161|      0|      mrb_value kdict;
 2162|      0|      mrb_bool key_p = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2163|       |
 2164|      0|      if (kidx >= 0 && mrb_hash_p(kdict=regs[kidx])) {
  ------------------
  |  |  188|      0|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (2164:11): [True: 0, False: 0]
  ------------------
 2165|      0|        key_p = mrb_hash_key_p(mrb, kdict, k);
 2166|      0|      }
 2167|      0|      regs[a] = mrb_bool_value(key_p);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2168|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2169|      0|    }
 2170|       |
 2171|      0|    CASE(OP_KEYEND, Z) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2172|      0|      mrb_int kidx = mrb_ci_kidx(mrb->c->ci);
 2173|      0|      mrb_value kdict;
 2174|       |
 2175|      0|      if (kidx >= 0 && mrb_hash_p(kdict=regs[kidx]) && !mrb_hash_empty_p(mrb, kdict)) {
  ------------------
  |  |  188|      0|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (2175:11): [True: 0, False: 0]
  |  Branch (2175:56): [True: 0, False: 0]
  ------------------
 2176|      0|        mrb_value keys = mrb_hash_keys(mrb, kdict);
 2177|      0|        mrb_value key1 = RARRAY_PTR(keys)[0];
  ------------------
  |  |   73|      0|#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
  |  |  ------------------
  |  |  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2178|      0|        RAISE_FORMAT(mrb, E_ARGUMENT_ERROR, "unknown keyword: %v", key1);
  ------------------
  |  | 1164|      0|#define RAISE_FORMAT(mrb, c, fmt, ...)  RAISE_EXC(mrb, mrb_exc_new_str(mrb, c, mrb_format(mrb, fmt, __VA_ARGS__)))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2179|      0|      }
 2180|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2181|      0|    }
 2182|       |
 2183|      0|    CASE(OP_BREAK, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2184|      0|      c = OP_R_BREAK;
  ------------------
  |  |   23|      0|#define OP_R_BREAK  1
  ------------------
 2185|      0|      goto L_RETURN;
 2186|      0|    }
 2187|      0|    CASE(OP_RETURN_BLK, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2188|      0|      c = OP_R_RETURN;
  ------------------
  |  |   24|      0|#define OP_R_RETURN 2
  ------------------
 2189|      0|      goto L_RETURN;
 2190|      0|    }
 2191|   893k|    CASE(OP_RETURN, B)
  ------------------
  |  | 1280|   446k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2192|   893k|    c = OP_R_NORMAL;
  ------------------
  |  |   22|   446k|#define OP_R_NORMAL 0
  ------------------
 2193|   893k|    L_RETURN:
 2194|   446k|    {
 2195|   446k|      mrb_callinfo *ci;
 2196|       |
 2197|   446k|      ci = mrb->c->ci;
 2198|   446k|      if (mrb->exc) {
  ------------------
  |  Branch (2198:11): [True: 0, False: 446k]
  ------------------
 2199|    443|      L_RAISE:
 2200|    443|        ci = mrb->c->ci;
 2201|  1.21k|        while ((ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL)) == NULL) {
  ------------------
  |  | 1099|  1.21k|#define MRB_CATCH_FILTER_ALL    (MRB_CATCH_FILTER_RESCUE | MRB_CATCH_FILTER_ENSURE)
  |  |  ------------------
  |  |  |  | 1097|  1.21k|#define MRB_CATCH_FILTER_RESCUE (UINT32_C(1) << MRB_CATCH_RESCUE)
  |  |  ------------------
  |  |               #define MRB_CATCH_FILTER_ALL    (MRB_CATCH_FILTER_RESCUE | MRB_CATCH_FILTER_ENSURE)
  |  |  ------------------
  |  |  |  | 1098|  1.21k|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  ------------------
  |  Branch (2201:16): [True: 1.21k, False: 0]
  ------------------
 2202|  1.21k|          if (ci != mrb->c->cibase) {
  ------------------
  |  Branch (2202:15): [True: 771, False: 443]
  ------------------
 2203|    771|            ci = cipop(mrb);
 2204|    771|            if (ci[1].cci == CINFO_SKIP && prev_jmp) {
  ------------------
  |  |  335|  1.54k|#define CINFO_SKIP    1 // ignited mruby VM from C
  ------------------
  |  Branch (2204:17): [True: 0, False: 771]
  |  Branch (2204:44): [True: 0, False: 0]
  ------------------
 2205|      0|              mrb->jmp = prev_jmp;
 2206|      0|              MRB_THROW(prev_jmp);
  ------------------
  |  |   48|      0|#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
  |  |  ------------------
  |  |  |  |   41|      0|#define MRB_LONGJMP longjmp
  |  |  ------------------
  ------------------
 2207|      0|            }
 2208|    771|            pc = ci[0].pc;
 2209|    771|          }
 2210|    443|          else if (mrb->c == mrb->root_c) {
  ------------------
  |  Branch (2210:20): [True: 443, False: 0]
  ------------------
 2211|    443|            mrb->c->ci->stack = mrb->c->stbase;
 2212|    443|            goto L_STOP;
 2213|    443|          }
 2214|      0|          else {
 2215|      0|            struct mrb_context *c = mrb->c;
 2216|       |
 2217|      0|            c->status = MRB_FIBER_TERMINATED;
 2218|      0|            mrb->c = c->prev;
 2219|      0|            if (!mrb->c) mrb->c = mrb->root_c;
  ------------------
  |  Branch (2219:17): [True: 0, False: 0]
  ------------------
 2220|      0|            else c->prev = NULL;
 2221|      0|            goto L_RAISE;
 2222|      0|          }
 2223|  1.21k|        }
 2224|       |
 2225|      0|        if (FALSE) {
  ------------------
  |  |   51|      0|#  define FALSE 0
  |  |  ------------------
  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2226|      0|        L_CATCH_TAGGED_BREAK: /* from THROW_TAGGED_BREAK() or UNWIND_ENSURE() */
 2227|      0|          ci = mrb->c->ci;
 2228|      0|        }
 2229|      0|        proc = ci->proc;
 2230|      0|        irep = proc->body.irep;
 2231|      0|        pool = irep->pool;
 2232|      0|        syms = irep->syms;
 2233|      0|        stack_extend(mrb, irep->nregs);
 2234|      0|        pc = irep->iseq + mrb_irep_catch_handler_unpack(ch->target);
  ------------------
  |  |  124|      0|#define mrb_irep_catch_handler_unpack(v)    bin_to_uint32(v)
  ------------------
 2235|      0|      }
 2236|   446k|      else {
 2237|   446k|        mrb_int acc;
 2238|   446k|        mrb_value v;
 2239|       |
 2240|   446k|        ci = mrb->c->ci;
 2241|   446k|        v = regs[a];
  ------------------
  |  | 1335|   446k|#define regs (mrb->c->ci->stack)
  ------------------
 2242|   446k|        mrb_gc_protect(mrb, v);
 2243|   446k|        switch (c) {
 2244|      0|        case OP_R_RETURN:
  ------------------
  |  |   24|      0|#define OP_R_RETURN 2
  ------------------
  |  Branch (2244:9): [True: 0, False: 446k]
  ------------------
 2245|       |          /* Fall through to OP_R_NORMAL otherwise */
 2246|      0|          if (ci->cci == CINFO_NONE && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) {
  ------------------
  |  |  334|      0|#define CINFO_NONE    0 // called method from mruby VM (without C functions)
  ------------------
                        if (ci->cci == CINFO_NONE && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) {
  ------------------
  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                        if (ci->cci == CINFO_NONE && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) {
  ------------------
  |  |   68|      0|#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
  |  |  ------------------
  |  |  |  |   67|      0|#define MRB_PROC_STRICT 256
  |  |  ------------------
  ------------------
  |  Branch (2246:15): [True: 0, False: 0]
  |  Branch (2246:64): [True: 0, False: 0]
  ------------------
 2247|      0|            const struct RProc *dst;
 2248|      0|            mrb_callinfo *cibase;
 2249|      0|            cibase = mrb->c->cibase;
 2250|      0|            dst = top_proc(mrb, proc);
 2251|       |
 2252|      0|            if (MRB_PROC_ENV_P(dst)) {
  ------------------
  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2253|      0|              struct REnv *e = MRB_PROC_ENV(dst);
  ------------------
  |  |   73|      0|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2254|       |
 2255|      0|              if (!MRB_ENV_ONSTACK_P(e) || (e->cxt && e->cxt != mrb->c)) {
  ------------------
  |  |   30|      0|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
  |  Branch (2255:19): [True: 0, False: 0]
  |  Branch (2255:45): [True: 0, False: 0]
  |  Branch (2255:55): [True: 0, False: 0]
  ------------------
 2256|      0|                localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
 2257|      0|                goto L_RAISE;
 2258|      0|              }
 2259|      0|            }
 2260|       |            /* check jump destination */
 2261|      0|            while (cibase <= ci && ci->proc != dst) {
  ------------------
  |  Branch (2261:20): [True: 0, False: 0]
  |  Branch (2261:36): [True: 0, False: 0]
  ------------------
 2262|      0|              if (ci->cci > CINFO_NONE) { /* jump cross C boundary */
  ------------------
  |  |  334|      0|#define CINFO_NONE    0 // called method from mruby VM (without C functions)
  ------------------
  |  Branch (2262:19): [True: 0, False: 0]
  ------------------
 2263|      0|                localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
 2264|      0|                goto L_RAISE;
 2265|      0|              }
 2266|      0|              ci--;
 2267|      0|            }
 2268|      0|            if (ci <= cibase) { /* no jump destination */
  ------------------
  |  Branch (2268:17): [True: 0, False: 0]
  ------------------
 2269|      0|              localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
 2270|      0|              goto L_RAISE;
 2271|      0|            }
 2272|      0|            ci = mrb->c->ci;
 2273|      0|            while (cibase <= ci && ci->proc != dst) {
  ------------------
  |  Branch (2273:20): [True: 0, False: 0]
  |  Branch (2273:36): [True: 0, False: 0]
  ------------------
 2274|      0|              CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_BLOCK) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 2275|      0|                cibase = mrb->c->cibase;
 2276|      0|                dst = top_proc(mrb, proc);
 2277|      0|              }
 2278|      0|              CHECKPOINT_MAIN(RBREAK_TAG_RETURN_BLOCK) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|      0|    do {
  ------------------
 2279|      0|                UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_BLOCK, proc, v);
  ------------------
  |  | 1211|      0|  do { \
  |  | 1212|      0|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|      0|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|      0|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2280|      0|              }
 2281|      0|              CHECKPOINT_END(RBREAK_TAG_RETURN_BLOCK);
  ------------------
  |  | 1248|      0|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2282|      0|              ci = cipop(mrb);
 2283|      0|              pc = ci->pc;
 2284|      0|            }
 2285|      0|            proc = ci->proc;
 2286|      0|            mrb->exc = NULL; /* clear break object */
 2287|      0|            break;
 2288|      0|          }
 2289|       |          /* fallthrough */
 2290|   446k|        case OP_R_NORMAL:
  ------------------
  |  |   22|   446k|#define OP_R_NORMAL 0
  ------------------
  |  Branch (2290:9): [True: 446k, False: 0]
  ------------------
 2291|   446k|        NORMAL_RETURN:
 2292|   446k|          if (ci == mrb->c->cibase) {
  ------------------
  |  Branch (2292:15): [True: 46.4k, False: 400k]
  ------------------
 2293|  46.4k|            struct mrb_context *c;
 2294|  46.4k|            c = mrb->c;
 2295|       |
 2296|  46.4k|            if (!c->prev) {
  ------------------
  |  Branch (2296:17): [True: 46.4k, False: 0]
  ------------------
 2297|  46.4k|              if (c != mrb->root_c) {
  ------------------
  |  Branch (2297:19): [True: 0, False: 46.4k]
  ------------------
 2298|       |                /* fiber termination should transfer to root */
 2299|      0|                c->prev = mrb->root_c;
 2300|      0|              }
 2301|  46.4k|              else { /* toplevel return */
 2302|  46.4k|                regs[irep->nlocals] = v;
  ------------------
  |  | 1335|  46.4k|#define regs (mrb->c->ci->stack)
  ------------------
 2303|  46.4k|                goto CHECKPOINT_LABEL_MAKE(RBREAK_TAG_STOP);
 2304|  46.4k|              }
 2305|  46.4k|            }
 2306|      0|            else if (!c->vmexec && c->prev->ci == c->prev->cibase) {
  ------------------
  |  Branch (2306:22): [True: 0, False: 0]
  |  Branch (2306:36): [True: 0, False: 0]
  ------------------
 2307|      0|              RAISE_LIT(mrb, E_FIBER_ERROR, "double resume");
  ------------------
  |  | 1163|      0|#define RAISE_LIT(mrb, c, str)          RAISE_EXC(mrb, mrb_exc_new_lit(mrb, c, str))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2308|      0|            }
 2309|      0|            CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_TOPLEVEL) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 2310|      0|              c = mrb->c;
 2311|      0|            }
 2312|      0|            CHECKPOINT_MAIN(RBREAK_TAG_RETURN_TOPLEVEL) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|      0|    do {
  ------------------
 2313|      0|              UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_TOPLEVEL, proc, v);
  ------------------
  |  | 1211|      0|  do { \
  |  | 1212|      0|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|      0|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|      0|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2314|      0|            }
 2315|      0|            CHECKPOINT_END(RBREAK_TAG_RETURN_TOPLEVEL);
  ------------------
  |  | 1248|      0|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2316|       |            /* automatic yield at the end */
 2317|      0|            c->status = MRB_FIBER_TERMINATED;
 2318|      0|            mrb->c = c->prev;
 2319|      0|            mrb->c->status = MRB_FIBER_RUNNING;
 2320|      0|            c->prev = NULL;
 2321|      0|            if (c->vmexec) {
  ------------------
  |  Branch (2321:17): [True: 0, False: 0]
  ------------------
 2322|      0|              mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2323|      0|              c->vmexec = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2324|      0|              mrb->jmp = prev_jmp;
 2325|      0|              return v;
 2326|      0|            }
 2327|      0|            ci = mrb->c->ci;
 2328|      0|          }
 2329|   400k|          CHECKPOINT_RESTORE(RBREAK_TAG_RETURN) {
  ------------------
  |  | 1237|   400k|  do { \
  |  | 1238|   400k|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|   400k|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 2330|       |            /* do nothing */
 2331|      0|          }
 2332|   800k|          CHECKPOINT_MAIN(RBREAK_TAG_RETURN) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|   400k|    do {
  ------------------
 2333|   800k|            UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN, proc, v);
  ------------------
  |  | 1211|   400k|  do { \
  |  | 1212|   400k|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|   400k|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|   400k|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 400k]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|   400k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2334|   800k|          }
 2335|   800k|          CHECKPOINT_END(RBREAK_TAG_RETURN);
  ------------------
  |  | 1248|   400k|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|   400k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2336|   400k|          mrb->exc = NULL; /* clear break object */
 2337|   400k|          break;
 2338|      0|        case OP_R_BREAK:
  ------------------
  |  |   23|      0|#define OP_R_BREAK  1
  ------------------
  |  Branch (2338:9): [True: 0, False: 446k]
  ------------------
 2339|      0|          if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN;
  ------------------
  |  |   68|      0|#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
  |  |  ------------------
  |  |  |  |   67|      0|#define MRB_PROC_STRICT 256
  |  |  ------------------
  |  |  |  Branch (68:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2340|      0|          if (MRB_PROC_ORPHAN_P(proc)) {
  ------------------
  |  |   70|      0|#define MRB_PROC_ORPHAN_P(p) (((p)->flags & MRB_PROC_ORPHAN) != 0)
  |  |  ------------------
  |  |  |  |   69|      0|#define MRB_PROC_ORPHAN 512
  |  |  ------------------
  |  |  |  Branch (70:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2341|      0|          L_BREAK_ERROR:
 2342|      0|            RAISE_LIT(mrb, E_LOCALJUMP_ERROR, "break from proc-closure");
  ------------------
  |  | 1163|      0|#define RAISE_LIT(mrb, c, str)          RAISE_EXC(mrb, mrb_exc_new_lit(mrb, c, str))
  |  |  ------------------
  |  |  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  |  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  |  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  |  |  | 1160|      0|  goto L_RAISE; \
  |  |  |  | 1161|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2343|      0|          }
 2344|      0|          if (!MRB_PROC_ENV_P(proc) || !MRB_ENV_ONSTACK_P(MRB_PROC_ENV(proc))) {
  ------------------
  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  ------------------
                        if (!MRB_PROC_ENV_P(proc) || !MRB_ENV_ONSTACK_P(MRB_PROC_ENV(proc))) {
  ------------------
  |  |   30|      0|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  |  |  |  Branch (30:33): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2344:15): [True: 0, False: 0]
  |  Branch (2344:40): [True: 0, False: 0]
  ------------------
 2345|      0|            goto L_BREAK_ERROR;
 2346|      0|          }
 2347|      0|          else {
 2348|      0|            struct REnv *e = MRB_PROC_ENV(proc);
  ------------------
  |  |   73|      0|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2349|       |
 2350|      0|            if (e->cxt != mrb->c) {
  ------------------
  |  Branch (2350:17): [True: 0, False: 0]
  ------------------
 2351|      0|              goto L_BREAK_ERROR;
 2352|      0|            }
 2353|      0|          }
 2354|      0|          CHECKPOINT_RESTORE(RBREAK_TAG_BREAK) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 2355|       |            /* do nothing */
 2356|      0|          }
 2357|      0|          CHECKPOINT_MAIN(RBREAK_TAG_BREAK) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|      0|    do {
  ------------------
 2358|      0|            UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK, proc, v);
  ------------------
  |  | 1211|      0|  do { \
  |  | 1212|      0|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|      0|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|      0|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2359|      0|          }
 2360|      0|          CHECKPOINT_END(RBREAK_TAG_BREAK);
  ------------------
  |  | 1248|      0|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2361|       |          /* break from fiber block */
 2362|      0|          if (ci == mrb->c->cibase && ci->pc) {
  ------------------
  |  Branch (2362:15): [True: 0, False: 0]
  |  Branch (2362:39): [True: 0, False: 0]
  ------------------
 2363|      0|            struct mrb_context *c = mrb->c;
 2364|       |
 2365|      0|            mrb->c = c->prev;
 2366|      0|            c->prev = NULL;
 2367|      0|            ci = mrb->c->ci;
 2368|      0|          }
 2369|      0|          if (ci->cci > CINFO_NONE) {
  ------------------
  |  |  334|      0|#define CINFO_NONE    0 // called method from mruby VM (without C functions)
  ------------------
  |  Branch (2369:15): [True: 0, False: 0]
  ------------------
 2370|      0|            ci = cipop(mrb);
 2371|      0|            mrb->exc = (struct RObject*)break_new(mrb, RBREAK_TAG_BREAK, proc, v);
 2372|      0|            mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2373|      0|            mrb->c->vmexec = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2374|      0|            mrb->jmp = prev_jmp;
 2375|      0|            MRB_THROW(prev_jmp);
  ------------------
  |  |   48|      0|#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
  |  |  ------------------
  |  |  |  |   41|      0|#define MRB_LONGJMP longjmp
  |  |  ------------------
  ------------------
 2376|      0|          }
 2377|      0|          if (FALSE) {
  ------------------
  |  |   51|      0|#  define FALSE 0
  |  |  ------------------
  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2378|      0|            struct RBreak *brk;
 2379|       |
 2380|      0|          L_BREAK:
 2381|      0|            brk = (struct RBreak*)mrb->exc;
 2382|      0|            proc = mrb_break_proc_get(brk);
  ------------------
  |  |   70|      0|#define mrb_break_proc_get(brk) ((brk)->proc)
  ------------------
 2383|      0|            v = mrb_break_value_get(brk);
  ------------------
  |  |   45|      0|#define mrb_break_value_get(brk) ((brk)->val)
  ------------------
 2384|      0|            ci = mrb->c->ci;
 2385|       |
 2386|      0|            switch (mrb_break_tag_get(brk)) {
 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  ------------------
  |  | 1052|      0|  f(RBREAK_TAG_BREAK, 0) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1053|      0|  f(RBREAK_TAG_BREAK_UPPER, 1) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1054|      0|  f(RBREAK_TAG_BREAK_INTARGET, 2) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1055|      0|  f(RBREAK_TAG_RETURN_BLOCK, 3) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1056|      0|  f(RBREAK_TAG_RETURN, 4) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1057|      0|  f(RBREAK_TAG_RETURN_TOPLEVEL, 5) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1058|      0|  f(RBREAK_TAG_JUMP, 6) \
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1059|      0|  f(RBREAK_TAG_STOP, 7)
  |  |  ------------------
  |  |  |  | 2388|      0|              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2387|      0|#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (2387:36): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2389|      0|#undef DISPATCH_CHECKPOINTS
 2390|      0|              default:
  ------------------
  |  Branch (2390:15): [True: 0, False: 0]
  ------------------
 2391|      0|                mrb_assert(!"wrong break tag");
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 2392|      0|            }
 2393|      0|          }
 2394|      0|          while (mrb->c->cibase < ci && ci[-1].proc != proc->upper) {
  ------------------
  |  Branch (2394:18): [True: 0, False: 0]
  |  Branch (2394:41): [True: 0, False: 0]
  ------------------
 2395|      0|            if (ci[-1].cci == CINFO_SKIP) {
  ------------------
  |  |  335|      0|#define CINFO_SKIP    1 // ignited mruby VM from C
  ------------------
  |  Branch (2395:17): [True: 0, False: 0]
  ------------------
 2396|      0|              goto L_BREAK_ERROR;
 2397|      0|            }
 2398|      0|            CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_UPPER) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 2399|       |              /* do nothing */
 2400|      0|            }
 2401|      0|            CHECKPOINT_MAIN(RBREAK_TAG_BREAK_UPPER) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|      0|    do {
  ------------------
 2402|      0|              UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_UPPER, proc, v);
  ------------------
  |  | 1211|      0|  do { \
  |  | 1212|      0|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|      0|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|      0|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2403|      0|            }
 2404|      0|            CHECKPOINT_END(RBREAK_TAG_BREAK_UPPER);
  ------------------
  |  | 1248|      0|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2405|      0|            ci = cipop(mrb);
 2406|      0|            pc = ci->pc;
 2407|      0|          }
 2408|      0|          CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_INTARGET) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|      0|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|      0|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|      0|      do {
  ------------------
 2409|       |            /* do nothing */
 2410|      0|          }
 2411|      0|          CHECKPOINT_MAIN(RBREAK_TAG_BREAK_INTARGET) {
  ------------------
  |  | 1243|      0|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|      0|    } \
  |  | 1245|      0|    do {
  ------------------
 2412|      0|            UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_INTARGET, proc, v);
  ------------------
  |  | 1211|      0|  do { \
  |  | 1212|      0|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|      0|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|      0|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2413|      0|          }
 2414|      0|          CHECKPOINT_END(RBREAK_TAG_BREAK_INTARGET);
  ------------------
  |  | 1248|      0|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2415|      0|          if (ci == mrb->c->cibase) {
  ------------------
  |  Branch (2415:15): [True: 0, False: 0]
  ------------------
 2416|      0|            goto L_BREAK_ERROR;
 2417|      0|          }
 2418|      0|          mrb->exc = NULL; /* clear break object */
 2419|      0|          break;
 2420|      0|        default:
  ------------------
  |  Branch (2420:9): [True: 0, False: 446k]
  ------------------
 2421|       |          /* cannot happen */
 2422|      0|          break;
 2423|   446k|        }
 2424|   400k|        mrb_assert(ci == mrb->c->ci);
  ------------------
  |  |   68|   400k|#define mrb_assert(p) ((void)0)
  ------------------
 2425|   400k|        mrb_assert(mrb->exc == NULL);
  ------------------
  |  |   68|   400k|#define mrb_assert(p) ((void)0)
  ------------------
 2426|       |
 2427|   400k|        if (mrb->c->vmexec && !CI_TARGET_CLASS(ci)) {
  ------------------
  |  |  267|      0|#define CI_TARGET_CLASS(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env->c : (ci)->u.target_class)
  |  |  ------------------
  |  |  |  Branch (267:31): [True: 0, False: 0]
  |  |  |  Branch (267:46): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2427:13): [True: 0, False: 400k]
  |  Branch (2427:31): [True: 0, False: 0]
  ------------------
 2428|      0|          mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2429|      0|          mrb->c->vmexec = FALSE;
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2430|      0|          mrb->jmp = prev_jmp;
 2431|      0|          return v;
 2432|      0|        }
 2433|   400k|        acc = ci->cci;
 2434|   400k|        ci = cipop(mrb);
 2435|   400k|        if (acc == CINFO_SKIP || acc == CINFO_DIRECT) {
  ------------------
  |  |  335|   800k|#define CINFO_SKIP    1 // ignited mruby VM from C
  ------------------
                      if (acc == CINFO_SKIP || acc == CINFO_DIRECT) {
  ------------------
  |  |  336|   400k|#define CINFO_DIRECT  2 // called method from C
  ------------------
  |  Branch (2435:13): [True: 21, False: 400k]
  |  Branch (2435:34): [True: 0, False: 400k]
  ------------------
 2436|     21|          mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|     21|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2437|     21|          mrb->jmp = prev_jmp;
 2438|     21|          return v;
 2439|     21|        }
 2440|   400k|        pc = ci->pc;
 2441|   400k|        DEBUG(fprintf(stderr, "from :%s\n", mrb_sym_name(mrb, ci->mid)));
 2442|   400k|        proc = ci->proc;
 2443|   400k|        irep = proc->body.irep;
 2444|   400k|        pool = irep->pool;
 2445|   400k|        syms = irep->syms;
 2446|       |
 2447|   400k|        ci[1].stack[0] = v;
 2448|   400k|        mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|   400k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2449|   400k|      }
 2450|   400k|      JUMP;
  ------------------
  |  | 1282|   400k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|   400k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|   400k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|   400k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 400k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2451|   400k|    }
 2452|       |
 2453|   400k|    CASE(OP_BLKPUSH, BS) {
  ------------------
  |  | 1280|   400k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2454|      0|      int m1 = (b>>11)&0x3f;
 2455|      0|      int r  = (b>>10)&0x1;
 2456|      0|      int m2 = (b>>5)&0x1f;
 2457|      0|      int kd = (b>>4)&0x1;
 2458|      0|      int lv = (b>>0)&0xf;
 2459|      0|      mrb_value *stack;
 2460|       |
 2461|      0|      if (lv == 0) stack = regs + 1;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
  |  Branch (2461:11): [True: 0, False: 0]
  ------------------
 2462|      0|      else {
 2463|      0|        struct REnv *e = uvenv(mrb, lv-1);
 2464|      0|        if (!e || (!MRB_ENV_ONSTACK_P(e) && e->mid == 0) ||
  ------------------
  |  |   30|      0|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  ------------------
  |  Branch (2464:13): [True: 0, False: 0]
  |  Branch (2464:20): [True: 0, False: 0]
  |  Branch (2464:45): [True: 0, False: 0]
  ------------------
 2465|      0|            MRB_ENV_LEN(e) <= m1+r+m2+1) {
  ------------------
  |  |   27|      0|#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
  ------------------
  |  Branch (2465:13): [True: 0, False: 0]
  ------------------
 2466|      0|          localjump_error(mrb, LOCALJUMP_ERROR_YIELD);
 2467|      0|          goto L_RAISE;
 2468|      0|        }
 2469|      0|        stack = e->stack + 1;
 2470|      0|      }
 2471|      0|      if (mrb_nil_p(stack[m1+r+m2+kd])) {
  ------------------
  |  |  174|      0|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2472|      0|        localjump_error(mrb, LOCALJUMP_ERROR_YIELD);
 2473|      0|        goto L_RAISE;
 2474|      0|      }
 2475|      0|      regs[a] = stack[m1+r+m2+kd];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2476|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2477|      0|    }
 2478|       |
 2479|       |#if !defined(MRB_USE_BIGINT) || defined(MRB_INT32)
 2480|       |  L_INT_OVERFLOW:
 2481|       |    RAISE_LIT(mrb, E_RANGE_ERROR, "integer overflow");
 2482|       |#endif
 2483|       |
 2484|      0|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
 2485|      0|#define OP_MATH(op_name)                                                    \
 2486|       |  /* need to check if op is overridden */                                   \
 2487|      0|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {                  \
 2488|      0|    OP_MATH_CASE_INTEGER(op_name);                                          \
 2489|      0|    OP_MATH_CASE_FLOAT(op_name, integer, float);                            \
 2490|      0|    OP_MATH_CASE_FLOAT(op_name, float,  integer);                           \
 2491|      0|    OP_MATH_CASE_FLOAT(op_name, float,  float);                             \
 2492|      0|    OP_MATH_CASE_STRING_##op_name();                                        \
 2493|      0|    default:                                                                \
 2494|      0|      mid = MRB_OPSYM(op_name);                                             \
 2495|      0|      goto L_SEND_SYM;                                                      \
 2496|      0|  }                                                                         \
 2497|      0|  NEXT;
 2498|      0|#define OP_MATH_CASE_INTEGER(op_name)                                       \
 2499|      0|  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                              \
 2500|      0|    {                                                                       \
 2501|      0|      mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
 2502|      0|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
 2503|      0|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
 2504|      0|      }                                                                     \
 2505|      0|      else                                                                  \
 2506|      0|        SET_INT_VALUE(mrb,regs[a], z);                                      \
 2507|      0|    }                                                                       \
 2508|      0|    break
 2509|       |#ifdef MRB_NO_FLOAT
 2510|       |#define OP_MATH_CASE_FLOAT(op_name, t1, t2) (void)0
 2511|       |#else
 2512|      0|#define OP_MATH_CASE_FLOAT(op_name, t1, t2)                                     \
 2513|      0|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
 2514|      0|    {                                                                           \
 2515|      0|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
 2516|      0|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
 2517|      0|    }                                                                           \
 2518|      0|    break
 2519|      0|#endif
 2520|      0|#ifdef MRB_USE_BIGINT
 2521|      0|#define OP_MATH_OVERFLOW_INT(op,x,y) regs[a] = mrb_bint_##op##_ii(mrb,x,y)
 2522|       |#else
 2523|       |#define OP_MATH_OVERFLOW_INT(op,x,y) goto L_INT_OVERFLOW
 2524|       |#endif
 2525|      0|#define OP_MATH_CASE_STRING_add()                                           \
 2526|      0|  case TYPES2(MRB_TT_STRING, MRB_TT_STRING):                                \
 2527|      0|    regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);                        \
 2528|      0|    mrb_gc_arena_restore(mrb, ai);                                          \
 2529|      0|    break
 2530|      0|#define OP_MATH_CASE_STRING_sub() (void)0
 2531|      0|#define OP_MATH_CASE_STRING_mul() (void)0
 2532|      0|#define OP_MATH_OP_add +
 2533|      0|#define OP_MATH_OP_sub -
 2534|      0|#define OP_MATH_OP_mul *
 2535|      0|#define OP_MATH_TT_integer MRB_TT_INTEGER
 2536|      0|#define OP_MATH_TT_float   MRB_TT_FLOAT
 2537|       |
 2538|  16.4k|    CASE(OP_ADD, B) {
  ------------------
  |  | 1280|  8.28k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2539|  16.4k|      OP_MATH(add);
  ------------------
  |  | 2487|  8.28k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {                  \
  |  |  ------------------
  |  |  |  | 2484|  8.28k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2488|  3.10k|    OP_MATH_CASE_INTEGER(op_name);                                          \
  |  |  ------------------
  |  |  |  | 2499|  3.10k|  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                              \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|  3.10k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2499:3): [True: 3.10k, False: 5.17k]
  |  |  |  |  ------------------
  |  |  |  | 2500|  3.10k|    {                                                                       \
  |  |  |  | 2501|  3.10k|      mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  3.10k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  |                     mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  3.10k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  | 2502|  3.10k|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2502:11): [True: 1.38k, False: 1.72k]
  |  |  |  |  ------------------
  |  |  |  | 2503|  1.38k|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2521|  1.38k|#define OP_MATH_OVERFLOW_INT(op,x,y) regs[a] = mrb_bint_##op##_ii(mrb,x,y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1335|  1.38k|#define regs (mrb->c->ci->stack)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 2504|  1.38k|      }                                                                     \
  |  |  |  | 2505|  3.10k|      else                                                                  \
  |  |  |  | 2506|  3.10k|        SET_INT_VALUE(mrb,regs[a], z);                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|  1.72k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  |  |  ------------------
  |  |  |  | 2507|  3.10k|    }                                                                       \
  |  |  |  | 2508|  3.10k|    break
  |  |  ------------------
  |  | 2489|    552|    OP_MATH_CASE_FLOAT(op_name, integer, float);                            \
  |  |  ------------------
  |  |  |  | 2513|    552|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    552|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 552, False: 7.73k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    552|    {                                                                           \
  |  |  |  | 2515|    552|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    552|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    552|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    552|    }                                                                           \
  |  |  |  | 2518|    552|    break
  |  |  ------------------
  |  | 2490|    609|    OP_MATH_CASE_FLOAT(op_name, float,  integer);                           \
  |  |  ------------------
  |  |  |  | 2513|    609|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    609|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 609, False: 7.67k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    609|    {                                                                           \
  |  |  |  | 2515|    609|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    609|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    609|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    609|    }                                                                           \
  |  |  |  | 2518|    609|    break
  |  |  ------------------
  |  | 2491|    290|    OP_MATH_CASE_FLOAT(op_name, float,  float);                             \
  |  |  ------------------
  |  |  |  | 2513|    290|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    290|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 290, False: 7.99k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    290|    {                                                                           \
  |  |  |  | 2515|    290|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    290|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    290|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    290|    }                                                                           \
  |  |  |  | 2518|    290|    break
  |  |  ------------------
  |  | 2492|      0|    OP_MATH_CASE_STRING_##op_name();                                        \
  |  | 2493|  3.72k|    default:                                                                \
  |  |  ------------------
  |  |  |  Branch (2493:5): [True: 3.72k, False: 4.56k]
  |  |  ------------------
  |  | 2494|  3.72k|      mid = MRB_OPSYM(op_name);                                             \
  |  |  ------------------
  |  |  |  |   12|  3.72k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2495|  3.72k|      goto L_SEND_SYM;                                                      \
  |  | 2496|  8.28k|  }                                                                         \
  |  | 2497|  8.28k|  NEXT;
  |  |  ------------------
  |  |  |  | 1281|  4.56k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  4.56k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  4.56k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 4.56k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2540|  4.56k|    }
 2541|       |
 2542|  17.9k|    CASE(OP_SUB, B) {
  ------------------
  |  | 1280|  9.10k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2543|  17.9k|      OP_MATH(sub);
  ------------------
  |  | 2487|  9.10k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {                  \
  |  |  ------------------
  |  |  |  | 2484|  9.10k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2488|  3.62k|    OP_MATH_CASE_INTEGER(op_name);                                          \
  |  |  ------------------
  |  |  |  | 2499|  3.62k|  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                              \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|  3.62k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2499:3): [True: 3.62k, False: 5.48k]
  |  |  |  |  ------------------
  |  |  |  | 2500|  3.62k|    {                                                                       \
  |  |  |  | 2501|  3.62k|      mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  3.62k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  |                     mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  3.62k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  | 2502|  3.62k|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2502:11): [True: 686, False: 2.93k]
  |  |  |  |  ------------------
  |  |  |  | 2503|    686|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2521|    686|#define OP_MATH_OVERFLOW_INT(op,x,y) regs[a] = mrb_bint_##op##_ii(mrb,x,y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1335|    686|#define regs (mrb->c->ci->stack)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 2504|    686|      }                                                                     \
  |  |  |  | 2505|  3.62k|      else                                                                  \
  |  |  |  | 2506|  3.62k|        SET_INT_VALUE(mrb,regs[a], z);                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|  2.93k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  |  |  ------------------
  |  |  |  | 2507|  3.62k|    }                                                                       \
  |  |  |  | 2508|  3.62k|    break
  |  |  ------------------
  |  | 2489|    507|    OP_MATH_CASE_FLOAT(op_name, integer, float);                            \
  |  |  ------------------
  |  |  |  | 2513|    507|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    507|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 507, False: 8.59k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    507|    {                                                                           \
  |  |  |  | 2515|    507|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    507|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    507|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    507|    }                                                                           \
  |  |  |  | 2518|    507|    break
  |  |  ------------------
  |  | 2490|    150|    OP_MATH_CASE_FLOAT(op_name, float,  integer);                           \
  |  |  ------------------
  |  |  |  | 2513|    150|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    150|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 150, False: 8.95k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    150|    {                                                                           \
  |  |  |  | 2515|    150|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    150|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    150|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    150|    }                                                                           \
  |  |  |  | 2518|    150|    break
  |  |  ------------------
  |  | 2491|    273|    OP_MATH_CASE_FLOAT(op_name, float,  float);                             \
  |  |  ------------------
  |  |  |  | 2513|    273|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    273|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 273, False: 8.82k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    273|    {                                                                           \
  |  |  |  | 2515|    273|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    273|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    273|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    273|    }                                                                           \
  |  |  |  | 2518|    273|    break
  |  |  ------------------
  |  | 2492|      0|    OP_MATH_CASE_STRING_##op_name();                                        \
  |  | 2493|  4.55k|    default:                                                                \
  |  |  ------------------
  |  |  |  Branch (2493:5): [True: 4.55k, False: 4.55k]
  |  |  ------------------
  |  | 2494|  4.55k|      mid = MRB_OPSYM(op_name);                                             \
  |  |  ------------------
  |  |  |  |   12|  4.55k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2495|  4.55k|      goto L_SEND_SYM;                                                      \
  |  | 2496|  9.10k|  }                                                                         \
  |  | 2497|  9.10k|  NEXT;
  |  |  ------------------
  |  |  |  | 1281|  4.55k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  4.55k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  4.55k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 4.55k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2544|  4.55k|    }
 2545|       |
 2546|  19.3k|    CASE(OP_MUL, B) {
  ------------------
  |  | 1280|  9.89k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2547|  19.3k|      OP_MATH(mul);
  ------------------
  |  | 2487|  9.89k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {                  \
  |  |  ------------------
  |  |  |  | 2484|  9.89k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2488|  4.35k|    OP_MATH_CASE_INTEGER(op_name);                                          \
  |  |  ------------------
  |  |  |  | 2499|  4.35k|  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                              \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|  4.35k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2499:3): [True: 4.35k, False: 5.54k]
  |  |  |  |  ------------------
  |  |  |  | 2500|  4.35k|    {                                                                       \
  |  |  |  | 2501|  4.35k|      mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  4.35k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  |                     mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  4.35k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  | 2502|  4.35k|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2502:11): [True: 1.51k, False: 2.83k]
  |  |  |  |  ------------------
  |  |  |  | 2503|  1.51k|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2521|  1.51k|#define OP_MATH_OVERFLOW_INT(op,x,y) regs[a] = mrb_bint_##op##_ii(mrb,x,y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1335|  1.51k|#define regs (mrb->c->ci->stack)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 2504|  1.51k|      }                                                                     \
  |  |  |  | 2505|  4.35k|      else                                                                  \
  |  |  |  | 2506|  4.35k|        SET_INT_VALUE(mrb,regs[a], z);                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|  2.83k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  |  |  ------------------
  |  |  |  | 2507|  4.35k|    }                                                                       \
  |  |  |  | 2508|  4.35k|    break
  |  |  ------------------
  |  | 2489|    569|    OP_MATH_CASE_FLOAT(op_name, integer, float);                            \
  |  |  ------------------
  |  |  |  | 2513|    569|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    569|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 569, False: 9.32k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    569|    {                                                                           \
  |  |  |  | 2515|    569|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    569|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    569|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    569|    }                                                                           \
  |  |  |  | 2518|    569|    break
  |  |  ------------------
  |  | 2490|    722|    OP_MATH_CASE_FLOAT(op_name, float,  integer);                           \
  |  |  ------------------
  |  |  |  | 2513|    722|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    722|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 722, False: 9.17k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    722|    {                                                                           \
  |  |  |  | 2515|    722|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    722|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    722|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    722|    }                                                                           \
  |  |  |  | 2518|    722|    break
  |  |  ------------------
  |  | 2491|    437|    OP_MATH_CASE_FLOAT(op_name, float,  float);                             \
  |  |  ------------------
  |  |  |  | 2513|    437|  case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2484|    437|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2513:3): [True: 437, False: 9.45k]
  |  |  |  |  ------------------
  |  |  |  | 2514|    437|    {                                                                           \
  |  |  |  | 2515|    437|      mrb_float z = mrb_##t1(regs[a]) OP_MATH_OP_##op_name mrb_##t2(regs[a+1]); \
  |  |  |  | 2516|    437|      SET_FLOAT_VALUE(mrb, regs[a], z);                                         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    437|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2517|    437|    }                                                                           \
  |  |  |  | 2518|    437|    break
  |  |  ------------------
  |  | 2492|      0|    OP_MATH_CASE_STRING_##op_name();                                        \
  |  | 2493|  3.81k|    default:                                                                \
  |  |  ------------------
  |  |  |  Branch (2493:5): [True: 3.81k, False: 6.08k]
  |  |  ------------------
  |  | 2494|  3.81k|      mid = MRB_OPSYM(op_name);                                             \
  |  |  ------------------
  |  |  |  |   12|  3.81k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2495|  3.81k|      goto L_SEND_SYM;                                                      \
  |  | 2496|  9.89k|  }                                                                         \
  |  | 2497|  9.89k|  NEXT;
  |  |  ------------------
  |  |  |  | 1281|  6.08k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  6.08k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  6.08k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 6.08k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2548|  6.08k|    }
 2549|       |
 2550|  14.7k|    CASE(OP_DIV, B) {
  ------------------
  |  | 1280|  7.43k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2551|  14.7k|#ifndef MRB_NO_FLOAT
 2552|  14.7k|      mrb_float x, y, f;
 2553|  14.7k|#endif
 2554|       |
 2555|       |      /* need to check if op is overridden */
 2556|  14.7k|      switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
  ------------------
  |  | 2484|  7.43k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  ------------------
 2557|  1.71k|      case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):
  ------------------
  |  | 2484|  1.71k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  ------------------
  |  Branch (2557:7): [True: 1.71k, False: 5.72k]
  ------------------
 2558|  1.71k|        {
 2559|  1.71k|          mrb_int x = mrb_integer(regs[a]);
  ------------------
  |  |  166|  1.71k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 2560|  1.71k|          mrb_int y = mrb_integer(regs[a+1]);
  ------------------
  |  |  166|  1.71k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 2561|  1.71k|          regs[a] = mrb_div_int_value(mrb, x, y);
  ------------------
  |  | 1335|  1.71k|#define regs (mrb->c->ci->stack)
  ------------------
 2562|  1.71k|        }
 2563|  1.71k|        NEXT;
  ------------------
  |  | 1281|  1.71k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.71k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.71k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.71k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2564|  1.71k|#ifndef MRB_NO_FLOAT
 2565|  2.38k|      case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):
  ------------------
  |  | 2484|  2.38k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  ------------------
  |  Branch (2565:7): [True: 670, False: 6.76k]
  ------------------
 2566|  2.38k|        x = (mrb_float)mrb_integer(regs[a]);
  ------------------
  |  |  166|  2.38k|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 2567|  2.38k|        y = mrb_float(regs[a+1]);
  ------------------
  |  |  155|  2.38k|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 2568|  2.38k|        break;
 2569|    466|      case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):
  ------------------
  |  | 2484|    466|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  ------------------
  |  Branch (2569:7): [True: 466, False: 6.97k]
  ------------------
 2570|    466|        x = mrb_float(regs[a]);
  ------------------
  |  |  155|    466|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 2571|    466|        y = (mrb_float)mrb_integer(regs[a+1]);
  ------------------
  |  |  166|    466|#define mrb_integer(o) mrb_integer_func(o)
  ------------------
 2572|    466|        break;
 2573|    509|      case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
  ------------------
  |  | 2484|    509|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  ------------------
  |  Branch (2573:7): [True: 509, False: 6.92k]
  ------------------
 2574|    509|        x = mrb_float(regs[a]);
  ------------------
  |  |  155|    509|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 2575|    509|        y = mrb_float(regs[a+1]);
  ------------------
  |  |  155|    509|#define mrb_float(o) mrb_word_boxing_value_float(o)
  ------------------
 2576|    509|        break;
 2577|      0|#endif
 2578|  4.07k|      default:
  ------------------
  |  Branch (2578:7): [True: 4.07k, False: 3.36k]
  ------------------
 2579|  4.07k|        mid = MRB_OPSYM(div);
  ------------------
  |  |   12|  4.07k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  ------------------
 2580|  4.07k|        goto L_SEND_SYM;
 2581|  14.7k|      }
 2582|       |
 2583|  1.64k|#ifndef MRB_NO_FLOAT
 2584|  1.64k|      f = mrb_div_float(x, y);
 2585|  1.64k|      SET_FLOAT_VALUE(mrb, regs[a], f);
  ------------------
  |  |  206|  1.64k|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  ------------------
 2586|  1.64k|#endif
 2587|  1.64k|      NEXT;
  ------------------
  |  | 1281|  1.64k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.64k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.64k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.64k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2588|  1.64k|    }
 2589|       |
 2590|      0|#define OP_MATHI(op_name)                                                   \
 2591|       |  /* need to check if op is overridden */                                   \
 2592|      0|  switch (mrb_type(regs[a])) {                                              \
 2593|      0|    OP_MATHI_CASE_INTEGER(op_name);                                         \
 2594|      0|    OP_MATHI_CASE_FLOAT(op_name);                                           \
 2595|      0|    default:                                                                \
 2596|      0|      SET_INT_VALUE(mrb,regs[a+1], b);                                      \
 2597|      0|      mid = MRB_OPSYM(op_name);                                             \
 2598|      0|      goto L_SEND_SYM;                                                      \
 2599|      0|  }                                                                         \
 2600|      0|  NEXT;
 2601|      0|#define OP_MATHI_CASE_INTEGER(op_name)                                      \
 2602|      0|  case MRB_TT_INTEGER:                                                      \
 2603|      0|    {                                                                       \
 2604|      0|      mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z;                  \
 2605|      0|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
 2606|      0|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
 2607|      0|      }                                                                     \
 2608|      0|      else                                                                  \
 2609|      0|        SET_INT_VALUE(mrb,regs[a], z);                                      \
 2610|      0|    }                                                                       \
 2611|      0|    break
 2612|       |#ifdef MRB_NO_FLOAT
 2613|       |#define OP_MATHI_CASE_FLOAT(op_name) (void)0
 2614|       |#else
 2615|      0|#define OP_MATHI_CASE_FLOAT(op_name)                                        \
 2616|      0|  case MRB_TT_FLOAT:                                                        \
 2617|      0|    {                                                                       \
 2618|      0|      mrb_float z = mrb_float(regs[a]) OP_MATH_OP_##op_name b;              \
 2619|      0|      SET_FLOAT_VALUE(mrb, regs[a], z);                                     \
 2620|      0|    }                                                                       \
 2621|      0|    break
 2622|      0|#endif
 2623|       |
 2624|   136k|    CASE(OP_ADDI, BB) {
  ------------------
  |  | 1280|  68.3k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2625|   136k|      OP_MATHI(add);
  ------------------
  |  | 2592|  68.3k|  switch (mrb_type(regs[a])) {                                              \
  |  |  ------------------
  |  |  |  | 1335|  68.3k|#define regs (mrb->c->ci->stack)
  |  |  ------------------
  |  | 2593|  66.5k|    OP_MATHI_CASE_INTEGER(op_name);                                         \
  |  |  ------------------
  |  |  |  | 2602|  66.5k|  case MRB_TT_INTEGER:                                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2602:3): [True: 66.5k, False: 1.81k]
  |  |  |  |  ------------------
  |  |  |  | 2603|  66.5k|    {                                                                       \
  |  |  |  | 2604|  66.5k|      mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z;                  \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  66.5k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  | 2605|  66.5k|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2605:11): [True: 47, False: 66.5k]
  |  |  |  |  ------------------
  |  |  |  | 2606|     47|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2521|     47|#define OP_MATH_OVERFLOW_INT(op,x,y) regs[a] = mrb_bint_##op##_ii(mrb,x,y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1335|     47|#define regs (mrb->c->ci->stack)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 2607|     47|      }                                                                     \
  |  |  |  | 2608|  66.5k|      else                                                                  \
  |  |  |  | 2609|  66.5k|        SET_INT_VALUE(mrb,regs[a], z);                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|  66.5k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  |  |  ------------------
  |  |  |  | 2610|  66.5k|    }                                                                       \
  |  |  |  | 2611|  66.5k|    break
  |  |  ------------------
  |  | 2594|    338|    OP_MATHI_CASE_FLOAT(op_name);                                           \
  |  |  ------------------
  |  |  |  | 2616|    338|  case MRB_TT_FLOAT:                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2616:3): [True: 338, False: 68.0k]
  |  |  |  |  ------------------
  |  |  |  | 2617|    338|    {                                                                       \
  |  |  |  | 2618|    338|      mrb_float z = mrb_float(regs[a]) OP_MATH_OP_##op_name b;              \
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    338|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  |  | 2619|    338|      SET_FLOAT_VALUE(mrb, regs[a], z);                                     \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    338|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2620|    338|    }                                                                       \
  |  |  |  | 2621|    338|    break
  |  |  ------------------
  |  | 2595|  1.47k|    default:                                                                \
  |  |  ------------------
  |  |  |  Branch (2595:5): [True: 1.47k, False: 66.8k]
  |  |  ------------------
  |  | 2596|  1.47k|      SET_INT_VALUE(mrb,regs[a+1], b);                                      \
  |  |  ------------------
  |  |  |  |  214|  1.47k|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  ------------------
  |  | 2597|  1.47k|      mid = MRB_OPSYM(op_name);                                             \
  |  |  ------------------
  |  |  |  |   12|  1.47k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2598|  1.47k|      goto L_SEND_SYM;                                                      \
  |  | 2599|  68.3k|  }                                                                         \
  |  | 2600|  68.3k|  NEXT;
  |  |  ------------------
  |  |  |  | 1281|  66.8k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  66.8k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  66.8k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 66.8k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2626|  66.8k|    }
 2627|       |
 2628|  66.8k|    CASE(OP_SUBI, BB) {
  ------------------
  |  | 1280|  66.8k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2629|  5.12k|      OP_MATHI(sub);
  ------------------
  |  | 2592|  2.67k|  switch (mrb_type(regs[a])) {                                              \
  |  |  ------------------
  |  |  |  | 1335|  2.67k|#define regs (mrb->c->ci->stack)
  |  |  ------------------
  |  | 2593|  1.56k|    OP_MATHI_CASE_INTEGER(op_name);                                         \
  |  |  ------------------
  |  |  |  | 2602|  1.56k|  case MRB_TT_INTEGER:                                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2602:3): [True: 1.56k, False: 1.11k]
  |  |  |  |  ------------------
  |  |  |  | 2603|  1.56k|    {                                                                       \
  |  |  |  | 2604|  1.56k|      mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z;                  \
  |  |  |  |  ------------------
  |  |  |  |  |  |  166|  1.56k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  ------------------
  |  |  |  | 2605|  1.56k|      if (mrb_int_##op_name##_overflow(x, y, &z)) {                         \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2605:11): [True: 595, False: 971]
  |  |  |  |  ------------------
  |  |  |  | 2606|    595|        OP_MATH_OVERFLOW_INT(op_name,x,y);                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2521|    595|#define OP_MATH_OVERFLOW_INT(op,x,y) regs[a] = mrb_bint_##op##_ii(mrb,x,y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1335|    595|#define regs (mrb->c->ci->stack)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 2607|    595|      }                                                                     \
  |  |  |  | 2608|  1.56k|      else                                                                  \
  |  |  |  | 2609|  1.56k|        SET_INT_VALUE(mrb,regs[a], z);                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  214|    971|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  |  |  ------------------
  |  |  |  | 2610|  1.56k|    }                                                                       \
  |  |  |  | 2611|  1.56k|    break
  |  |  ------------------
  |  | 2594|    454|    OP_MATHI_CASE_FLOAT(op_name);                                           \
  |  |  ------------------
  |  |  |  | 2616|    454|  case MRB_TT_FLOAT:                                                        \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (2616:3): [True: 454, False: 2.22k]
  |  |  |  |  ------------------
  |  |  |  | 2617|    454|    {                                                                       \
  |  |  |  | 2618|    454|      mrb_float z = mrb_float(regs[a]) OP_MATH_OP_##op_name b;              \
  |  |  |  |  ------------------
  |  |  |  |  |  |  155|    454|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  ------------------
  |  |  |  | 2619|    454|      SET_FLOAT_VALUE(mrb, regs[a], z);                                     \
  |  |  |  |  ------------------
  |  |  |  |  |  |  206|    454|#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
  |  |  |  |  ------------------
  |  |  |  | 2620|    454|    }                                                                       \
  |  |  |  | 2621|    454|    break
  |  |  ------------------
  |  | 2595|    658|    default:                                                                \
  |  |  ------------------
  |  |  |  Branch (2595:5): [True: 658, False: 2.02k]
  |  |  ------------------
  |  | 2596|    658|      SET_INT_VALUE(mrb,regs[a+1], b);                                      \
  |  |  ------------------
  |  |  |  |  214|    658|#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
  |  |  ------------------
  |  | 2597|    658|      mid = MRB_OPSYM(op_name);                                             \
  |  |  ------------------
  |  |  |  |   12|    658|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2598|    658|      goto L_SEND_SYM;                                                      \
  |  | 2599|  2.67k|  }                                                                         \
  |  | 2600|  2.67k|  NEXT;
  |  |  ------------------
  |  |  |  | 1281|  2.02k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|  2.02k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|  2.02k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 2.02k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2630|  2.02k|    }
 2631|       |
 2632|      0|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
 2633|       |
 2634|       |#ifdef MRB_NO_FLOAT
 2635|       |#define OP_CMP(op,sym) do {\
 2636|       |  int result;\
 2637|       |  /* need to check if - is overridden */\
 2638|       |  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
 2639|       |  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
 2640|       |    result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\
 2641|       |    break;\
 2642|       |  default:\
 2643|       |    mid = MRB_OPSYM(sym);\
 2644|       |    goto L_SEND_SYM;\
 2645|       |  }\
 2646|       |  if (result) {\
 2647|       |    SET_TRUE_VALUE(regs[a]);\
 2648|       |  }\
 2649|       |  else {\
 2650|       |    SET_FALSE_VALUE(regs[a]);\
 2651|       |  }\
 2652|       |} while(0)
 2653|       |#else
 2654|      0|#define OP_CMP(op, sym) do {\
 2655|      0|  int result;\
 2656|       |  /* need to check if - is overridden */\
 2657|      0|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
 2658|      0|  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
 2659|      0|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
 2660|      0|    break;\
 2661|      0|  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
 2662|      0|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
 2663|      0|    break;\
 2664|      0|  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
 2665|      0|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
 2666|      0|    break;\
 2667|      0|  case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
 2668|      0|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
 2669|      0|    break;\
 2670|      0|  default:\
 2671|      0|    mid = MRB_OPSYM(sym);\
 2672|      0|    goto L_SEND_SYM;\
 2673|      0|  }\
 2674|      0|  if (result) {\
 2675|      0|    SET_TRUE_VALUE(regs[a]);\
 2676|      0|  }\
 2677|      0|  else {\
 2678|      0|    SET_FALSE_VALUE(regs[a]);\
 2679|      0|  }\
 2680|      0|} while(0)
 2681|      0|#endif
 2682|       |
 2683|   161k|    CASE(OP_EQ, B) {
  ------------------
  |  | 1280|  80.9k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2684|   161k|      if (mrb_obj_eq(mrb, regs[a], regs[a+1])) {
  ------------------
  |  | 1335|  80.9k|#define regs (mrb->c->ci->stack)
  ------------------
                    if (mrb_obj_eq(mrb, regs[a], regs[a+1])) {
  ------------------
  |  | 1335|  80.9k|#define regs (mrb->c->ci->stack)
  ------------------
  |  Branch (2684:11): [True: 49.1k, False: 31.8k]
  ------------------
 2685|  49.1k|        SET_TRUE_VALUE(regs[a]);
  ------------------
  |  |  212|  49.1k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  ------------------
 2686|  49.1k|      }
 2687|  31.8k|      else {
 2688|  31.8k|        OP_CMP(==,eq);
  ------------------
  |  | 2654|  31.8k|#define OP_CMP(op, sym) do {\
  |  | 2655|  31.8k|  int result;\
  |  | 2656|  31.8k|  /* need to check if - is overridden */\
  |  | 2657|  31.8k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
  |  |  ------------------
  |  |  |  | 2484|  31.8k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2658|    666|  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|    666|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2658:3): [True: 666, False: 31.1k]
  |  |  ------------------
  |  | 2659|    666|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|    666|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|    666|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    666|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|    666|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    666|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2660|    666|    break;\
  |  | 2661|    207|  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|    207|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2661:3): [True: 207, False: 31.6k]
  |  |  ------------------
  |  | 2662|    207|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|    207|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    207|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    207|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    207|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    207|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2663|    207|    break;\
  |  | 2664|    329|  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|    329|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2664:3): [True: 329, False: 31.4k]
  |  |  ------------------
  |  | 2665|    329|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|    329|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|    329|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    329|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|    329|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    329|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2666|    329|    break;\
  |  | 2667|     76|  case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|     76|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2667:3): [True: 76, False: 31.7k]
  |  |  ------------------
  |  | 2668|     76|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|     76|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     76|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     76|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     76|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     76|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2669|     76|    break;\
  |  | 2670|  30.5k|  default:\
  |  |  ------------------
  |  |  |  Branch (2670:3): [True: 30.5k, False: 1.27k]
  |  |  ------------------
  |  | 2671|  30.5k|    mid = MRB_OPSYM(sym);\
  |  |  ------------------
  |  |  |  |   12|  30.5k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2672|  30.5k|    goto L_SEND_SYM;\
  |  | 2673|  31.8k|  }\
  |  | 2674|  31.8k|  if (result) {\
  |  |  ------------------
  |  |  |  Branch (2674:7): [True: 516, False: 762]
  |  |  ------------------
  |  | 2675|    516|    SET_TRUE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  212|    516|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  | 2676|    516|  }\
  |  | 2677|  1.27k|  else {\
  |  | 2678|    762|    SET_FALSE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  211|    762|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  | 2679|    762|  }\
  |  | 2680|  1.27k|} while(0)
  |  |  ------------------
  |  |  |  Branch (2680:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2689|  31.8k|      }
 2690|  50.4k|      NEXT;
  ------------------
  |  | 1281|  50.4k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  50.4k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  50.4k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 50.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2691|  50.4k|    }
 2692|       |
 2693|   212k|    CASE(OP_LT, B) {
  ------------------
  |  | 1280|   106k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2694|   212k|      OP_CMP(<,lt);
  ------------------
  |  | 2654|   106k|#define OP_CMP(op, sym) do {\
  |  | 2655|   106k|  int result;\
  |  | 2656|   106k|  /* need to check if - is overridden */\
  |  | 2657|   106k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
  |  |  ------------------
  |  |  |  | 2484|   106k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2658|   105k|  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|   105k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2658:3): [True: 105k, False: 1.37k]
  |  |  ------------------
  |  | 2659|   105k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|   105k|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|   105k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|   105k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|   105k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|   105k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2660|   105k|    break;\
  |  | 2661|    173|  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|    173|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2661:3): [True: 173, False: 106k]
  |  |  ------------------
  |  | 2662|    173|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|    173|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    173|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    173|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    173|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    173|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2663|    173|    break;\
  |  | 2664|    969|  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|    969|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2664:3): [True: 969, False: 105k]
  |  |  ------------------
  |  | 2665|    969|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|    969|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|    969|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    969|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|    969|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    969|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2666|    969|    break;\
  |  | 2667|     57|  case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|     57|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2667:3): [True: 57, False: 106k]
  |  |  ------------------
  |  | 2668|     57|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|     57|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     57|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     57|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     57|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     57|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2669|     57|    break;\
  |  | 2670|    171|  default:\
  |  |  ------------------
  |  |  |  Branch (2670:3): [True: 171, False: 106k]
  |  |  ------------------
  |  | 2671|    171|    mid = MRB_OPSYM(sym);\
  |  |  ------------------
  |  |  |  |   12|    171|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2672|    171|    goto L_SEND_SYM;\
  |  | 2673|   106k|  }\
  |  | 2674|   106k|  if (result) {\
  |  |  ------------------
  |  |  |  Branch (2674:7): [True: 65.8k, False: 40.3k]
  |  |  ------------------
  |  | 2675|  65.8k|    SET_TRUE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  212|  65.8k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  | 2676|  65.8k|  }\
  |  | 2677|   106k|  else {\
  |  | 2678|  40.3k|    SET_FALSE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  211|  40.3k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  | 2679|  40.3k|  }\
  |  | 2680|   106k|} while(0)
  |  |  ------------------
  |  |  |  Branch (2680:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2695|   106k|      NEXT;
  ------------------
  |  | 1281|   106k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   106k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   106k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 106k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2696|   106k|    }
 2697|       |
 2698|   106k|    CASE(OP_LE, B) {
  ------------------
  |  | 1280|   106k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2699|  9.12k|      OP_CMP(<=,le);
  ------------------
  |  | 2654|  4.57k|#define OP_CMP(op, sym) do {\
  |  | 2655|  4.57k|  int result;\
  |  | 2656|  4.57k|  /* need to check if - is overridden */\
  |  | 2657|  4.57k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
  |  |  ------------------
  |  |  |  | 2484|  4.57k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2658|  1.66k|  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|  1.66k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2658:3): [True: 1.66k, False: 2.90k]
  |  |  ------------------
  |  | 2659|  1.66k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|  1.66k|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|  1.66k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|  1.66k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|  1.66k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|  1.66k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2660|  1.66k|    break;\
  |  | 2661|    775|  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|    775|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2661:3): [True: 775, False: 3.79k]
  |  |  ------------------
  |  | 2662|    775|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|    775|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    775|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    775|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    775|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    775|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2663|    775|    break;\
  |  | 2664|     52|  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|     52|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2664:3): [True: 52, False: 4.52k]
  |  |  ------------------
  |  | 2665|     52|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|     52|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|     52|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     52|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|     52|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|     52|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2666|     52|    break;\
  |  | 2667|    136|  case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|    136|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2667:3): [True: 136, False: 4.43k]
  |  |  ------------------
  |  | 2668|    136|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|    136|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|    136|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    136|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|    136|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    136|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2669|    136|    break;\
  |  | 2670|  1.94k|  default:\
  |  |  ------------------
  |  |  |  Branch (2670:3): [True: 1.94k, False: 2.63k]
  |  |  ------------------
  |  | 2671|  1.94k|    mid = MRB_OPSYM(sym);\
  |  |  ------------------
  |  |  |  |   12|  1.94k|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2672|  1.94k|    goto L_SEND_SYM;\
  |  | 2673|  4.57k|  }\
  |  | 2674|  4.57k|  if (result) {\
  |  |  ------------------
  |  |  |  Branch (2674:7): [True: 942, False: 1.68k]
  |  |  ------------------
  |  | 2675|    942|    SET_TRUE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  212|    942|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  | 2676|    942|  }\
  |  | 2677|  2.63k|  else {\
  |  | 2678|  1.68k|    SET_FALSE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  211|  1.68k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  | 2679|  1.68k|  }\
  |  | 2680|  2.63k|} while(0)
  |  |  ------------------
  |  |  |  Branch (2680:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2700|  2.63k|      NEXT;
  ------------------
  |  | 1281|  2.63k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  2.63k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  2.63k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 2.63k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2701|  2.63k|    }
 2702|       |
 2703|  8.65k|    CASE(OP_GT, B) {
  ------------------
  |  | 1280|  4.35k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2704|  8.65k|      OP_CMP(>,gt);
  ------------------
  |  | 2654|  4.35k|#define OP_CMP(op, sym) do {\
  |  | 2655|  4.35k|  int result;\
  |  | 2656|  4.35k|  /* need to check if - is overridden */\
  |  | 2657|  4.35k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
  |  |  ------------------
  |  |  |  | 2484|  4.35k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2658|  3.55k|  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|  3.55k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2658:3): [True: 3.55k, False: 799]
  |  |  ------------------
  |  | 2659|  3.55k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|  3.55k|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|  3.55k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|  3.55k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|  3.55k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|  3.55k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2660|  3.55k|    break;\
  |  | 2661|    221|  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|    221|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2661:3): [True: 221, False: 4.13k]
  |  |  ------------------
  |  | 2662|    221|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|    221|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    221|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    221|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    221|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    221|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2663|    221|    break;\
  |  | 2664|    175|  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|    175|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2664:3): [True: 175, False: 4.17k]
  |  |  ------------------
  |  | 2665|    175|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|    175|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|    175|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    175|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|    175|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    175|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2666|    175|    break;\
  |  | 2667|     61|  case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|     61|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2667:3): [True: 61, False: 4.29k]
  |  |  ------------------
  |  | 2668|     61|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|     61|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     61|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     61|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     61|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     61|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2669|     61|    break;\
  |  | 2670|    342|  default:\
  |  |  ------------------
  |  |  |  Branch (2670:3): [True: 342, False: 4.01k]
  |  |  ------------------
  |  | 2671|    342|    mid = MRB_OPSYM(sym);\
  |  |  ------------------
  |  |  |  |   12|    342|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2672|    342|    goto L_SEND_SYM;\
  |  | 2673|  4.35k|  }\
  |  | 2674|  4.35k|  if (result) {\
  |  |  ------------------
  |  |  |  Branch (2674:7): [True: 246, False: 3.76k]
  |  |  ------------------
  |  | 2675|    246|    SET_TRUE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  212|    246|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  | 2676|    246|  }\
  |  | 2677|  4.01k|  else {\
  |  | 2678|  3.76k|    SET_FALSE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  211|  3.76k|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  | 2679|  3.76k|  }\
  |  | 2680|  4.01k|} while(0)
  |  |  ------------------
  |  |  |  Branch (2680:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2705|  4.01k|      NEXT;
  ------------------
  |  | 1281|  4.01k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  4.01k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  4.01k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 4.01k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2706|  4.01k|    }
 2707|       |
 2708|  4.01k|    CASE(OP_GE, B) {
  ------------------
  |  | 1280|  4.01k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2709|  3.06k|      OP_CMP(>=,ge);
  ------------------
  |  | 2654|  1.57k|#define OP_CMP(op, sym) do {\
  |  | 2655|  1.57k|  int result;\
  |  | 2656|  1.57k|  /* need to check if - is overridden */\
  |  | 2657|  1.57k|  switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
  |  |  ------------------
  |  |  |  | 2484|  1.57k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  | 2658|  1.03k|  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|  1.03k|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2658:3): [True: 1.03k, False: 542]
  |  |  ------------------
  |  | 2659|  1.03k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|  1.03k|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|  1.03k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|  1.03k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2659|  1.03k|    result = OP_CMP_BODY(op,mrb_integer,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|  1.03k|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2660|  1.03k|    break;\
  |  | 2661|    184|  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|    184|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2661:3): [True: 184, False: 1.39k]
  |  |  ------------------
  |  | 2662|    184|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|    184|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    184|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|    184|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2662|    184|    result = OP_CMP_BODY(op,mrb_integer,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|    184|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2663|    184|    break;\
  |  | 2664|     73|  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
  |  |  ------------------
  |  |  |  | 2484|     73|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2664:3): [True: 73, False: 1.50k]
  |  |  ------------------
  |  | 2665|     73|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  ------------------
  |  |  |  | 2632|     73|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|     73|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     73|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2665|     73|    result = OP_CMP_BODY(op,mrb_float,mrb_integer);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  166|     73|#define mrb_integer(o) mrb_integer_func(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2666|     73|    break;\
  |  | 2667|     26|  case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
  |  |  ------------------
  |  |  |  | 2484|     26|#define TYPES2(a,b) ((((uint16_t)(a))<<8)|(((uint16_t)(b))&0xff))
  |  |  ------------------
  |  |  |  Branch (2667:3): [True: 26, False: 1.55k]
  |  |  ------------------
  |  | 2668|     26|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  ------------------
  |  |  |  | 2632|     26|#define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     26|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     26|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2668|     26|    result = OP_CMP_BODY(op,mrb_float,mrb_float);\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  155|     26|#define mrb_float(o) mrb_word_boxing_value_float(o)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2669|     26|    break;\
  |  | 2670|    259|  default:\
  |  |  ------------------
  |  |  |  Branch (2670:3): [True: 259, False: 1.32k]
  |  |  ------------------
  |  | 2671|    259|    mid = MRB_OPSYM(sym);\
  |  |  ------------------
  |  |  |  |   12|    259|#define MRB_OPSYM(name) MRB_OPSYM__##name
  |  |  ------------------
  |  | 2672|    259|    goto L_SEND_SYM;\
  |  | 2673|  1.57k|  }\
  |  | 2674|  1.57k|  if (result) {\
  |  |  ------------------
  |  |  |  Branch (2674:7): [True: 1.19k, False: 123]
  |  |  ------------------
  |  | 2675|  1.19k|    SET_TRUE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  212|  1.19k|#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
  |  |  ------------------
  |  | 2676|  1.19k|  }\
  |  | 2677|  1.32k|  else {\
  |  | 2678|    123|    SET_FALSE_VALUE(regs[a]);\
  |  |  ------------------
  |  |  |  |  211|    123|#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
  |  |  ------------------
  |  | 2679|    123|  }\
  |  | 2680|  1.32k|} while(0)
  |  |  ------------------
  |  |  |  Branch (2680:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2710|  1.32k|      NEXT;
  ------------------
  |  | 1281|  1.32k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.32k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.32k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.32k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2711|  1.32k|    }
 2712|       |
 2713|   172k|    CASE(OP_ARRAY, BB) {
  ------------------
  |  | 1280|  86.2k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2714|   172k|      regs[a] = ary_new_from_regs(mrb, b, a);
  ------------------
  |  | 1335|  86.2k|#define regs (mrb->c->ci->stack)
  ------------------
 2715|   172k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  86.2k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2716|   172k|      NEXT;
  ------------------
  |  | 1281|  86.2k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  86.2k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  86.2k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 86.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2717|   172k|    }
 2718|   172k|    CASE(OP_ARRAY2, BBB) {
  ------------------
  |  | 1280|  86.2k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2719|      0|      regs[a] = ary_new_from_regs(mrb, c, b);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2720|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2721|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2722|      0|    }
 2723|       |
 2724|  95.1k|    CASE(OP_ARYCAT, B) {
  ------------------
  |  | 1280|  47.5k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2725|  95.1k|      mrb_value splat = mrb_ary_splat(mrb, regs[a+1]);
  ------------------
  |  | 1335|  47.5k|#define regs (mrb->c->ci->stack)
  ------------------
 2726|  95.1k|      if (mrb_nil_p(regs[a])) {
  ------------------
  |  |  174|  47.5k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 22.6k, False: 24.8k]
  |  |  ------------------
  ------------------
 2727|  22.6k|        regs[a] = splat;
  ------------------
  |  | 1335|  22.6k|#define regs (mrb->c->ci->stack)
  ------------------
 2728|  22.6k|      }
 2729|  24.8k|      else {
 2730|  24.8k|        mrb_assert(mrb_array_p(regs[a]));
  ------------------
  |  |   68|  24.8k|#define mrb_assert(p) ((void)0)
  ------------------
 2731|  24.8k|        mrb_ary_concat(mrb, regs[a], splat);
  ------------------
  |  | 1335|  24.8k|#define regs (mrb->c->ci->stack)
  ------------------
 2732|  24.8k|      }
 2733|  95.1k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  47.5k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2734|  95.1k|      NEXT;
  ------------------
  |  | 1281|  47.5k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  47.5k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  47.5k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 47.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2735|  95.1k|    }
 2736|       |
 2737|  95.1k|    CASE(OP_ARYPUSH, BB) {
  ------------------
  |  | 1280|  47.5k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2738|  3.32k|      mrb_assert(mrb_array_p(regs[a]));
  ------------------
  |  |   68|  1.66k|#define mrb_assert(p) ((void)0)
  ------------------
 2739|  24.0k|      for (mrb_int i=0; i<b; i++) {
  ------------------
  |  Branch (2739:25): [True: 22.4k, False: 1.66k]
  ------------------
 2740|  22.4k|        mrb_ary_push(mrb, regs[a], regs[a+i+1]);
  ------------------
  |  | 1335|  22.4k|#define regs (mrb->c->ci->stack)
  ------------------
                      mrb_ary_push(mrb, regs[a], regs[a+i+1]);
  ------------------
  |  | 1335|  22.4k|#define regs (mrb->c->ci->stack)
  ------------------
 2741|  22.4k|      }
 2742|  3.32k|      NEXT;
  ------------------
  |  | 1281|  1.66k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.66k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.66k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.66k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2743|  3.32k|    }
 2744|       |
 2745|  3.32k|    CASE(OP_ARYSPLAT, B) {
  ------------------
  |  | 1280|  1.66k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2746|      0|      mrb_value ary = mrb_ary_splat(mrb, regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2747|      0|      regs[a] = ary;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2748|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2749|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2750|      0|    }
 2751|       |
 2752|      0|    CASE(OP_AREF, BBB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2753|      0|      mrb_value v = regs[b];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2754|       |
 2755|      0|      if (!mrb_array_p(v)) {
  ------------------
  |  |  186|      0|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2756|      0|        if (c == 0) {
  ------------------
  |  Branch (2756:13): [True: 0, False: 0]
  ------------------
 2757|      0|          regs[a] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2758|      0|        }
 2759|      0|        else {
 2760|      0|          SET_NIL_VALUE(regs[a]);
  ------------------
  |  |  210|      0|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 2761|      0|        }
 2762|      0|      }
 2763|      0|      else {
 2764|      0|        v = mrb_ary_ref(mrb, v, c);
  ------------------
  |  |  231|      0|#define mrb_ary_ref(mrb, ary, n) mrb_ary_entry(ary, n)
  ------------------
 2765|      0|        regs[a] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2766|      0|      }
 2767|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2768|      0|    }
 2769|       |
 2770|      0|    CASE(OP_ASET, BBB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2771|      0|      mrb_assert(mrb_array_p(regs[a]));
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 2772|      0|      mrb_ary_set(mrb, regs[b], c, regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_ary_set(mrb, regs[b], c, regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2773|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2774|      0|    }
 2775|       |
 2776|      0|    CASE(OP_APOST, BBB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2777|      0|      mrb_value v = regs[a];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2778|      0|      int pre  = b;
 2779|      0|      int post = c;
 2780|      0|      struct RArray *ary;
 2781|      0|      int len, idx;
 2782|       |
 2783|      0|      if (!mrb_array_p(v)) {
  ------------------
  |  |  186|      0|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2784|      0|        v = ary_new_from_regs(mrb, 1, a);
 2785|      0|      }
 2786|      0|      ary = mrb_ary_ptr(v);
  ------------------
  |  |   51|      0|#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|      0|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2787|      0|      len = (int)ARY_LEN(ary);
  ------------------
  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  ------------------
  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2788|      0|      if (len > pre + post) {
  ------------------
  |  Branch (2788:11): [True: 0, False: 0]
  ------------------
 2789|      0|        v = mrb_ary_new_from_values(mrb, len - pre - post, ARY_PTR(ary)+pre);
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 2790|      0|        regs[a++] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2791|      0|        while (post--) {
  ------------------
  |  Branch (2791:16): [True: 0, False: 0]
  ------------------
 2792|      0|          regs[a++] = ARY_PTR(ary)[len-post-1];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                        regs[a++] = ARY_PTR(ary)[len-post-1];
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 2793|      0|        }
 2794|      0|      }
 2795|      0|      else {
 2796|      0|        v = mrb_ary_new_capa(mrb, 0);
 2797|      0|        regs[a++] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2798|      0|        for (idx=0; idx+pre<len; idx++) {
  ------------------
  |  Branch (2798:21): [True: 0, False: 0]
  ------------------
 2799|      0|          regs[a+idx] = ARY_PTR(ary)[pre+idx];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                        regs[a+idx] = ARY_PTR(ary)[pre+idx];
  ------------------
  |  |   71|      0|#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
  |  |  ------------------
  |  |  |  |   67|      0|#define ARY_EMBED_PTR(a) ((a)->as.ary)
  |  |  ------------------
  ------------------
 2800|      0|        }
 2801|      0|        while (idx < post) {
  ------------------
  |  Branch (2801:16): [True: 0, False: 0]
  ------------------
 2802|      0|          SET_NIL_VALUE(regs[a+idx]);
  ------------------
  |  |  210|      0|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
 2803|      0|          idx++;
 2804|      0|        }
 2805|      0|      }
 2806|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2807|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2808|      0|    }
 2809|       |
 2810|      0|    CASE(OP_INTERN, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2811|      0|      mrb_assert(mrb_string_p(regs[a]));
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 2812|      0|      mrb_sym sym = mrb_intern_str(mrb, regs[a]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2813|      0|      regs[a] = mrb_symbol_value(sym);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2814|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2815|      0|    }
 2816|       |
 2817|      0|    CASE(OP_SYMBOL, BB) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2818|      0|      size_t len;
 2819|      0|      mrb_sym sym;
 2820|       |
 2821|      0|      mrb_assert((pool[b].tt&IREP_TT_NFLAG)==0);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 2822|      0|      len = pool[b].tt >> 2;
 2823|      0|      if (pool[b].tt & IREP_TT_SFLAG) {
  ------------------
  |  |   28|      0|#define IREP_TT_SFLAG 2       /* static string flag */
  ------------------
  |  Branch (2823:11): [True: 0, False: 0]
  ------------------
 2824|      0|        sym = mrb_intern_static(mrb, pool[b].u.str, len);
 2825|      0|      }
 2826|      0|      else {
 2827|      0|        sym  = mrb_intern(mrb, pool[b].u.str, len);
 2828|      0|      }
 2829|      0|      regs[a] = mrb_symbol_value(sym);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2830|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2831|      0|    }
 2832|       |
 2833|   385k|    CASE(OP_STRING, BB) {
  ------------------
  |  | 1280|   246k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2834|   385k|      mrb_int len;
 2835|       |
 2836|   385k|      mrb_assert((pool[b].tt&IREP_TT_NFLAG)==0);
  ------------------
  |  |   68|   246k|#define mrb_assert(p) ((void)0)
  ------------------
 2837|   385k|      len = pool[b].tt >> 2;
 2838|   385k|      if (pool[b].tt & IREP_TT_SFLAG) {
  ------------------
  |  |   28|   246k|#define IREP_TT_SFLAG 2       /* static string flag */
  ------------------
  |  Branch (2838:11): [True: 0, False: 246k]
  ------------------
 2839|      0|        regs[a] = mrb_str_new_static(mrb, pool[b].u.str, len);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2840|      0|      }
 2841|   246k|      else {
 2842|   246k|        regs[a] = mrb_str_new(mrb, pool[b].u.str, len);
  ------------------
  |  | 1335|   246k|#define regs (mrb->c->ci->stack)
  ------------------
 2843|   246k|      }
 2844|   385k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|   246k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2845|   385k|      NEXT;
  ------------------
  |  | 1281|   246k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   246k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   246k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 246k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2846|   385k|    }
 2847|       |
 2848|   385k|    CASE(OP_STRCAT, B) {
  ------------------
  |  | 1280|   246k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2849|    210|      mrb_assert(mrb_string_p(regs[a]));
  ------------------
  |  |   68|    105|#define mrb_assert(p) ((void)0)
  ------------------
 2850|    210|      mrb_str_concat(mrb, regs[a], regs[a+1]);
  ------------------
  |  | 1335|    105|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_str_concat(mrb, regs[a], regs[a+1]);
  ------------------
  |  | 1335|    105|#define regs (mrb->c->ci->stack)
  ------------------
 2851|    210|      NEXT;
  ------------------
  |  | 1281|    105|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|    105|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|    105|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 105]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2852|    210|    }
 2853|       |
 2854|  5.11k|    CASE(OP_HASH, BB) {
  ------------------
  |  | 1280|  2.77k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2855|  5.11k|      mrb_value hash = mrb_hash_new_capa(mrb, b);
 2856|  5.11k|      int i;
 2857|  5.11k|      int lim = a+b*2;
 2858|       |
 2859|  85.2k|      for (i=a; i<lim; i+=2) {
  ------------------
  |  Branch (2859:17): [True: 82.4k, False: 2.77k]
  ------------------
 2860|  82.4k|        mrb_hash_set(mrb, hash, regs[i], regs[i+1]);
  ------------------
  |  | 1335|  82.4k|#define regs (mrb->c->ci->stack)
  ------------------
                      mrb_hash_set(mrb, hash, regs[i], regs[i+1]);
  ------------------
  |  | 1335|  82.4k|#define regs (mrb->c->ci->stack)
  ------------------
 2861|  82.4k|      }
 2862|  5.11k|      regs[a] = hash;
  ------------------
  |  | 1335|  2.77k|#define regs (mrb->c->ci->stack)
  ------------------
 2863|  5.11k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  2.77k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2864|  5.11k|      NEXT;
  ------------------
  |  | 1281|  2.77k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  2.77k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  2.77k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 2.77k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2865|  5.11k|    }
 2866|       |
 2867|  5.11k|    CASE(OP_HASHADD, BB) {
  ------------------
  |  | 1280|  2.77k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2868|  2.12k|      mrb_value hash;
 2869|  2.12k|      int i;
 2870|  2.12k|      int lim = a+b*2+1;
 2871|       |
 2872|  2.12k|      hash = regs[a];
  ------------------
  |  | 1335|  1.06k|#define regs (mrb->c->ci->stack)
  ------------------
 2873|  2.12k|      mrb_ensure_hash_type(mrb, hash);
 2874|  39.2k|      for (i=a+1; i<lim; i+=2) {
  ------------------
  |  Branch (2874:19): [True: 38.2k, False: 1.06k]
  ------------------
 2875|  38.2k|        mrb_hash_set(mrb, hash, regs[i], regs[i+1]);
  ------------------
  |  | 1335|  38.2k|#define regs (mrb->c->ci->stack)
  ------------------
                      mrb_hash_set(mrb, hash, regs[i], regs[i+1]);
  ------------------
  |  | 1335|  38.2k|#define regs (mrb->c->ci->stack)
  ------------------
 2876|  38.2k|      }
 2877|  2.12k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  1.06k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2878|  2.12k|      NEXT;
  ------------------
  |  | 1281|  1.06k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.06k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.06k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.06k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2879|  2.12k|    }
 2880|  2.12k|    CASE(OP_HASHCAT, B) {
  ------------------
  |  | 1280|  1.06k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2881|      0|      mrb_value hash = regs[a];
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2882|       |
 2883|      0|      mrb_assert(mrb_hash_p(hash));
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 2884|      0|      mrb_hash_merge(mrb, hash, regs[a+1]);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2885|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2886|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2887|      0|    }
 2888|       |
 2889|      0|    CASE(OP_LAMBDA, BB)
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2890|      0|    c = OP_L_LAMBDA;
  ------------------
  |  |   19|      0|#define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
  |  |  ------------------
  |  |  |  |   16|      0|#define OP_L_STRICT  1
  |  |  ------------------
  |  |               #define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
  |  |  ------------------
  |  |  |  |   17|      0|#define OP_L_CAPTURE 2
  |  |  ------------------
  ------------------
 2891|   833k|    L_MAKE_LAMBDA:
 2892|   833k|    {
 2893|   833k|      struct RProc *p;
 2894|   833k|      const mrb_irep *nirep = irep->reps[b];
 2895|       |
 2896|   833k|      if (c & OP_L_CAPTURE) {
  ------------------
  |  |   17|   833k|#define OP_L_CAPTURE 2
  ------------------
  |  Branch (2896:11): [True: 24.4k, False: 809k]
  ------------------
 2897|  24.4k|        p = mrb_closure_new(mrb, nirep);
 2898|  24.4k|      }
 2899|   809k|      else {
 2900|   809k|        p = mrb_proc_new(mrb, nirep);
 2901|   809k|        p->flags |= MRB_PROC_SCOPE;
  ------------------
  |  |   85|   809k|#define MRB_PROC_SCOPE 2048
  ------------------
 2902|   809k|      }
 2903|   833k|      if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
  ------------------
  |  |   16|   833k|#define OP_L_STRICT  1
  ------------------
                    if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
  ------------------
  |  |   67|   809k|#define MRB_PROC_STRICT 256
  ------------------
  |  Branch (2903:11): [True: 809k, False: 24.4k]
  ------------------
 2904|   833k|      regs[a] = mrb_obj_value(p);
  ------------------
  |  | 1335|   833k|#define regs (mrb->c->ci->stack)
  ------------------
 2905|   833k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|   833k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2906|   833k|      NEXT;
  ------------------
  |  | 1281|   833k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   833k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   833k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 833k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2907|   833k|    }
 2908|   833k|    CASE(OP_BLOCK, BB) {
  ------------------
  |  | 1280|   833k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2909|  24.4k|      c = OP_L_BLOCK;
  ------------------
  |  |   20|  24.4k|#define OP_L_BLOCK   OP_L_CAPTURE
  |  |  ------------------
  |  |  |  |   17|  24.4k|#define OP_L_CAPTURE 2
  |  |  ------------------
  ------------------
 2910|  24.4k|      goto L_MAKE_LAMBDA;
 2911|  24.4k|    }
 2912|   809k|    CASE(OP_METHOD, BB) {
  ------------------
  |  | 1280|   809k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2913|   809k|      c = OP_L_METHOD;
  ------------------
  |  |   18|   809k|#define OP_L_METHOD  OP_L_STRICT
  |  |  ------------------
  |  |  |  |   16|   809k|#define OP_L_STRICT  1
  |  |  ------------------
  ------------------
 2914|   809k|      goto L_MAKE_LAMBDA;
 2915|   809k|    }
 2916|       |
 2917|   809k|    CASE(OP_RANGE_INC, B) {
  ------------------
  |  | 1280|   809k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2918|      0|      mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], FALSE);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], FALSE);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], FALSE);
  ------------------
  |  |   51|      0|#  define FALSE 0
  ------------------
 2919|      0|      regs[a] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2920|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2921|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2922|      0|    }
 2923|       |
 2924|      0|    CASE(OP_RANGE_EXC, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2925|      0|      mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], TRUE);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], TRUE);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
                    mrb_value v = mrb_range_new(mrb, regs[a], regs[a+1], TRUE);
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 2926|      0|      regs[a] = v;
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2927|      0|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|      0|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2928|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2929|      0|    }
 2930|       |
 2931|      0|    CASE(OP_OCLASS, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2932|      0|      regs[a] = mrb_obj_value(mrb->object_class);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 2933|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2934|      0|    }
 2935|       |
 2936|   233k|    CASE(OP_CLASS, BB) {
  ------------------
  |  | 1280|   116k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2937|   233k|      struct RClass *c = 0, *baseclass;
 2938|   233k|      mrb_value base, super;
 2939|   233k|      mrb_sym id = syms[b];
 2940|       |
 2941|   233k|      base = regs[a];
  ------------------
  |  | 1335|   116k|#define regs (mrb->c->ci->stack)
  ------------------
 2942|   233k|      super = regs[a+1];
  ------------------
  |  | 1335|   116k|#define regs (mrb->c->ci->stack)
  ------------------
 2943|   233k|      if (mrb_nil_p(base)) {
  ------------------
  |  |  174|   116k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 116k, False: 0]
  |  |  ------------------
  ------------------
 2944|   116k|        baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
  ------------------
  |  |   74|   116k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|   116k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   116k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 116k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2945|   116k|        if (!baseclass) baseclass = mrb->object_class;
  ------------------
  |  Branch (2945:13): [True: 109k, False: 6.98k]
  ------------------
 2946|   116k|        base = mrb_obj_value(baseclass);
 2947|   116k|      }
 2948|   233k|      c = mrb_vm_define_class(mrb, base, super, id);
 2949|   233k|      regs[a] = mrb_obj_value(c);
  ------------------
  |  | 1335|   116k|#define regs (mrb->c->ci->stack)
  ------------------
 2950|   233k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|   116k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2951|   233k|      NEXT;
  ------------------
  |  | 1281|   116k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   116k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   116k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 116k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2952|   233k|    }
 2953|       |
 2954|   233k|    CASE(OP_MODULE, BB) {
  ------------------
  |  | 1280|   116k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2955|  52.3k|      struct RClass *cls = 0, *baseclass;
 2956|  52.3k|      mrb_value base;
 2957|  52.3k|      mrb_sym id = syms[b];
 2958|       |
 2959|  52.3k|      base = regs[a];
  ------------------
  |  | 1335|  26.1k|#define regs (mrb->c->ci->stack)
  ------------------
 2960|  52.3k|      if (mrb_nil_p(base)) {
  ------------------
  |  |  174|  26.1k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 26.1k, False: 0]
  |  |  ------------------
  ------------------
 2961|  26.1k|        baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
  ------------------
  |  |   74|  26.1k|#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
  |  |  ------------------
  |  |  |  |   72|  26.1k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  26.1k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 26.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2962|  26.1k|        if (!baseclass) baseclass = mrb->object_class;
  ------------------
  |  Branch (2962:13): [True: 24.4k, False: 1.74k]
  ------------------
 2963|  26.1k|        base = mrb_obj_value(baseclass);
 2964|  26.1k|      }
 2965|  52.3k|      cls = mrb_vm_define_module(mrb, base, id);
 2966|  52.3k|      regs[a] = mrb_obj_value(cls);
  ------------------
  |  | 1335|  26.1k|#define regs (mrb->c->ci->stack)
  ------------------
 2967|  52.3k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  26.1k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 2968|  52.3k|      NEXT;
  ------------------
  |  | 1281|  26.1k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  26.1k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  26.1k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 26.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2969|  52.3k|    }
 2970|       |
 2971|   247k|    CASE(OP_EXEC, BB)
  ------------------
  |  | 1280|   123k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2972|   247k|    {
 2973|   247k|      mrb_value recv = regs[a];
  ------------------
  |  | 1335|   123k|#define regs (mrb->c->ci->stack)
  ------------------
 2974|   247k|      struct RProc *p;
 2975|   247k|      const mrb_irep *nirep = irep->reps[b];
 2976|       |
 2977|       |      /* prepare closure */
 2978|   247k|      p = mrb_proc_new(mrb, nirep);
 2979|   247k|      p->c = NULL;
 2980|   247k|      mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)proc);
 2981|   247k|      MRB_PROC_SET_TARGET_CLASS(p, mrb_class_ptr(recv));
  ------------------
  |  |   75|   123k|#define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
  |  |   76|   123k|  if (MRB_PROC_ENV_P(p)) {\
  |  |  ------------------
  |  |  |  |   72|   123k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|   123k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 123k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|    (p)->e.env->c = (tc);\
  |  |   78|      0|    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)(tc));\
  |  |   79|      0|  }\
  |  |   80|   123k|  else {\
  |  |   81|   123k|    (p)->e.target_class = (tc);\
  |  |   82|   123k|    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)(tc));\
  |  |   83|   123k|  }\
  |  |   84|   123k|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2982|   247k|      p->flags |= MRB_PROC_SCOPE;
  ------------------
  |  |   85|   123k|#define MRB_PROC_SCOPE 2048
  ------------------
 2983|       |
 2984|       |      /* prepare call stack */
 2985|   247k|      cipush(mrb, a, 0, mrb_class_ptr(recv), p, NULL, 0, 0);
  ------------------
  |  |   24|   123k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   123k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2986|       |
 2987|   247k|      irep = p->body.irep;
 2988|   247k|      pool = irep->pool;
 2989|   247k|      syms = irep->syms;
 2990|   247k|      stack_extend(mrb, irep->nregs);
 2991|   247k|      stack_clear(regs+1, irep->nregs-1);
  ------------------
  |  | 1335|   123k|#define regs (mrb->c->ci->stack)
  ------------------
 2992|   247k|      pc = irep->iseq;
 2993|   247k|      JUMP;
  ------------------
  |  | 1282|   123k|#define JUMP NEXT
  |  |  ------------------
  |  |  |  | 1281|   123k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1260|   123k|#define BYTECODE_DECODER(x) (x)
  |  |  |  |  ------------------
  |  |  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  |  |  ------------------
  |  |  |  |  |  | 1252|   123k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (1252:50): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2994|   247k|    }
 2995|       |
 2996|  1.61M|    CASE(OP_DEF, BB) {
  ------------------
  |  | 1280|   809k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 2997|  1.61M|      struct RClass *target = mrb_class_ptr(regs[a]);
  ------------------
  |  |   24|   809k|#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   809k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2998|  1.61M|      struct RProc *p = mrb_proc_ptr(regs[a+1]);
  ------------------
  |  |   90|   809k|#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|   809k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
 2999|  1.61M|      mrb_method_t m;
 3000|  1.61M|      mrb_sym mid = syms[b];
 3001|       |
 3002|  1.61M|      MRB_METHOD_FROM_PROC(m, p);
  ------------------
  |  |  112|   809k|#define MRB_METHOD_FROM_PROC(m,pr) ((m)=(mrb_method_t)(pr))
  ------------------
 3003|  1.61M|      mrb_define_method_raw(mrb, target, mid, m);
 3004|  1.61M|      mrb_method_added(mrb, target, mid);
 3005|  1.61M|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|   809k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 3006|  1.61M|      regs[a] = mrb_symbol_value(mid);
  ------------------
  |  | 1335|   809k|#define regs (mrb->c->ci->stack)
  ------------------
 3007|  1.61M|      NEXT;
  ------------------
  |  | 1281|   809k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   809k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   809k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 809k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3008|  1.61M|    }
 3009|       |
 3010|  1.61M|    CASE(OP_SCLASS, B) {
  ------------------
  |  | 1280|   809k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3011|   181k|      regs[a] = mrb_singleton_class(mrb, regs[a]);
  ------------------
  |  | 1335|  90.7k|#define regs (mrb->c->ci->stack)
  ------------------
                    regs[a] = mrb_singleton_class(mrb, regs[a]);
  ------------------
  |  | 1335|  90.7k|#define regs (mrb->c->ci->stack)
  ------------------
 3012|   181k|      mrb_gc_arena_restore(mrb, ai);
  ------------------
  |  | 1307|  90.7k|#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx))
  ------------------
 3013|   181k|      NEXT;
  ------------------
  |  | 1281|  90.7k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  90.7k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  90.7k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 90.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3014|   181k|    }
 3015|       |
 3016|  1.44M|    CASE(OP_TCLASS, B) {
  ------------------
  |  | 1280|   723k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3017|  1.44M|      struct RClass *target = check_target_class(mrb);
 3018|  1.44M|      if (!target) goto L_RAISE;
  ------------------
  |  Branch (3018:11): [True: 0, False: 723k]
  ------------------
 3019|   723k|      regs[a] = mrb_obj_value(target);
  ------------------
  |  | 1335|   723k|#define regs (mrb->c->ci->stack)
  ------------------
 3020|   723k|      NEXT;
  ------------------
  |  | 1281|   723k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   723k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   723k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 723k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3021|   723k|    }
 3022|       |
 3023|   723k|    CASE(OP_ALIAS, BB) {
  ------------------
  |  | 1280|   723k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3024|   212k|      struct RClass *target = check_target_class(mrb);
 3025|       |
 3026|   212k|      if (!target) goto L_RAISE;
  ------------------
  |  Branch (3026:11): [True: 0, False: 106k]
  ------------------
 3027|   106k|      mrb_alias_method(mrb, target, syms[a], syms[b]);
 3028|   106k|      mrb_method_added(mrb, target, syms[a]);
 3029|   106k|      NEXT;
  ------------------
  |  | 1281|   106k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|   106k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|   106k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 106k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3030|   106k|    }
 3031|   106k|    CASE(OP_UNDEF, B) {
  ------------------
  |  | 1280|   106k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3032|  3.49k|      struct RClass *target = check_target_class(mrb);
 3033|       |
 3034|  3.49k|      if (!target) goto L_RAISE;
  ------------------
  |  Branch (3034:11): [True: 0, False: 1.74k]
  ------------------
 3035|  1.74k|      mrb_undef_method_id(mrb, target, syms[a]);
 3036|  1.74k|      NEXT;
  ------------------
  |  | 1281|  1.74k|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|  1.74k|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|  1.74k|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 1.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3037|  1.74k|    }
 3038|       |
 3039|  1.74k|    CASE(OP_DEBUG, Z) {
  ------------------
  |  | 1280|  1.74k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3040|      0|      FETCH_BBB();
  ------------------
  |  |   37|      0|#define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
  |  |  ------------------
  |  |  |  |   30|      0|#define READ_B() PEEK_B(pc++)
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|#define PEEK_B(pc) (*(pc))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
  |  |  ------------------
  |  |  |  |   30|      0|#define READ_B() PEEK_B(pc++)
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|#define PEEK_B(pc) (*(pc))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
  |  |  ------------------
  |  |  |  |   30|      0|#define READ_B() PEEK_B(pc++)
  |  |  |  |  ------------------
  |  |  |  |  |  |   26|      0|#define PEEK_B(pc) (*(pc))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (37:69): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3041|      0|#ifdef MRB_USE_DEBUG_HOOK
 3042|      0|      mrb->debug_op_hook(mrb, irep, pc, regs);
  ------------------
  |  | 1335|      0|#define regs (mrb->c->ci->stack)
  ------------------
 3043|       |#else
 3044|       |#ifndef MRB_NO_STDIO
 3045|       |      printf("OP_DEBUG %d %d %d\n", a, b, c);
 3046|       |#else
 3047|       |      abort();
 3048|       |#endif
 3049|       |#endif
 3050|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3051|      0|    }
 3052|       |
 3053|      0|    CASE(OP_ERR, B) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3054|      0|      size_t len = pool[a].tt >> 2;
 3055|      0|      mrb_value exc;
 3056|       |
 3057|      0|      mrb_assert((pool[a].tt&IREP_TT_NFLAG)==0);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
 3058|      0|      exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, pool[a].u.str, len);
  ------------------
  |  | 1384|      0|#define E_LOCALJUMP_ERROR    mrb_exc_get_id(mrb, MRB_ERROR_SYM(LocalJumpError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3059|      0|      RAISE_EXC(mrb, exc);
  ------------------
  |  | 1157|      0|#define RAISE_EXC(mrb, exc) do { \
  |  | 1158|      0|  mrb_value exc_value = (exc); \
  |  | 1159|      0|  mrb_exc_set(mrb, exc_value); \
  |  | 1160|      0|  goto L_RAISE; \
  |  | 1161|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (1161:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3060|      0|    }
 3061|       |
 3062|   410k|    CASE(OP_EXT1, Z) {
  ------------------
  |  | 1280|   205k|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3063|   410k|      insn = READ_B();
  ------------------
  |  |   30|   205k|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|   205k|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
 3064|   410k|      switch (insn) {
  ------------------
  |  Branch (3064:15): [True: 0, False: 205k]
  ------------------
 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
 3066|   410k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|    886|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  | 3065|    886|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 886, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|     60|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  | 3065|     60|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 60, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|    589|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3065|    589|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 589, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|     49|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  | 3065|     49|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 49, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|     79|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  | 3065|     79|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 79, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|    871|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  | 3065|    871|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 871, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|  90.5k|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  | 3065|  90.5k|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 90.5k, False: 114k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|    255|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  | 3065|    255|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 255, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|    200|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  | 3065|    200|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 200, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|    422|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  | 3065|    422|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 422, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|    202|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  | 3065|    202|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 202, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|    432|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  | 3065|    432|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 432, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|     40|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  | 3065|     40|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 40, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|     10|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3065|     10|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 10, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|      6|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  | 3065|      6|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 6, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|      0|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|      0|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|    205|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|    205|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 205, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|    205|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  | 3065|    205|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 205, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|    117|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 3065|    117|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 117, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|    101|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 3065|    101|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 101, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|      0|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|    399|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 3065|    399|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 399, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|    139|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|    139|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 139, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|    177|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3065|    177|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 177, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|    278|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|    278|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 278, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|    236|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3065|    236|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 236, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|    394|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|    394|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 394, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|    106|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|    106|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 106, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|    206|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|    206|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 206, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|     30|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|     30|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 30, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|     23|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|     23|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 23, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|     56|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|     56|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 56, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|     95|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  | 3065|     95|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 95, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|      0|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|      0|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|   107k|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  | 3065|   107k|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 107k, False: 97.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|    368|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  | 3065|    368|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 368, False: 204k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|      0|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|      0|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|      0|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|      0|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  | 3065|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3065:26): [True: 0, False: 205k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3067|   410k|#undef OPCODE
 3068|   410k|      }
 3069|      0|      pc--;
 3070|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3071|      0|    }
 3072|  1.29k|    CASE(OP_EXT2, Z) {
  ------------------
  |  | 1280|    646|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3073|  1.29k|      insn = READ_B();
  ------------------
  |  |   30|    646|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|    646|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
 3074|  1.29k|      switch (insn) {
  ------------------
  |  Branch (3074:15): [True: 0, False: 646]
  ------------------
 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
 3076|  1.29k|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|      0|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|     77|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  | 3075|     77|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 77, False: 569]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|      0|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|      0|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|      0|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|      0|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|      0|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|      0|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|      0|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|      0|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|      0|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|      0|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|      0|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|      0|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|      0|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|      0|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|      0|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|      0|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|      0|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|      0|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|      0|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|      0|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|      0|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|      0|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|      0|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|      0|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|      0|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|      0|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|     89|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 3075|     89|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 89, False: 557]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|      0|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|    422|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  | 3075|    422|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 422, False: 224]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|     58|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  | 3075|     58|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 58, False: 588]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|      0|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|      0|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|      0|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|      0|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  | 3075|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3075:26): [True: 0, False: 646]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3077|  1.29k|#undef OPCODE
 3078|  1.29k|      }
 3079|      0|      pc--;
 3080|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3081|      0|    }
 3082|    290|    CASE(OP_EXT3, Z) {
  ------------------
  |  | 1280|    145|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3083|    290|      insn = READ_B();
  ------------------
  |  |   30|    145|#define READ_B() PEEK_B(pc++)
  |  |  ------------------
  |  |  |  |   26|    145|#define PEEK_B(pc) (*(pc))
  |  |  ------------------
  ------------------
 3084|    290|      switch (insn) {
  ------------------
  |  Branch (3084:15): [True: 0, False: 145]
  ------------------
 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
 3086|    290|#include "mruby/ops.h"
  ------------------
  |  |    1|       |/* operand types:
  |  |    2|       |   + Z: no operand
  |  |    3|       |   + B: 8bit
  |  |    4|       |   + BB: 8+8bit
  |  |    5|       |   + BBB: 8+8+8bit
  |  |    6|       |   + BS: 8+16bit
  |  |    7|       |   + BSS: 8+16+16bit
  |  |    8|       |   + S: 16bit
  |  |    9|       |   + W: 24bit
  |  |   10|       |*/
  |  |   11|       |
  |  |   12|       |/*-----------------------------------------------------------------------
  |  |   13|       |operation code    operands      semantics
  |  |   14|       |------------------------------------------------------------------------*/
  |  |   15|      0|OPCODE(NOP,        Z)        /* no operation */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   16|      0|OPCODE(MOVE,       BB)       /* R[a] = R[b] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   17|     33|OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
  |  |  ------------------
  |  |  |  | 3085|     33|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 33, False: 112]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   18|      0|OPCODE(LOADI,      BB)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   19|      0|OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   20|      0|OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   21|      0|OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   22|      0|OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   23|      0|OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   24|      0|OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|      0|OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|      0|OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   27|      0|OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   28|      0|OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   29|      0|OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   30|      0|OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   32|      0|OPCODE(LOADNIL,    B)        /* R[a] = nil */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   33|      0|OPCODE(LOADSELF,   B)        /* R[a] = self */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   34|      0|OPCODE(LOADT,      B)        /* R[a] = true */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   35|      0|OPCODE(LOADF,      B)        /* R[a] = false */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   36|      0|OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   37|      0|OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   38|      0|OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   39|      0|OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   40|      0|OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|      0|OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|      0|OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|      0|OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|      0|OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   45|      0|OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   46|      0|OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   48|      0|OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   49|      0|OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   50|      0|OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   51|      0|OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|OPCODE(JMP,        S)        /* pc+=a */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   53|      0|OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   55|      0|OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   57|      0|OPCODE(EXCEPT,     B)        /* R[a] = exc */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   58|      0|OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   59|      0|OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   60|      0|OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   64|      0|OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   65|      0|OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   66|      0|OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   68|      0|OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   69|      0|OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   71|      0|OPCODE(RETURN,     B)        /* return R[a] (normal) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   72|      0|OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   73|      0|OPCODE(BREAK,      B)        /* break R[a] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   74|      0|OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   75|      0|OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   76|      0|OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   77|      0|OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   78|      0|OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   79|      0|OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   80|      0|OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   81|      0|OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|      0|OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   84|      0|OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   85|      0|OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   86|      0|OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   88|      0|OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   89|      0|OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   91|      0|OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|      0|OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|      0|OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|      0|OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|     98|OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
  |  |  ------------------
  |  |  |  | 3085|     98|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 98, False: 47]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|      0|OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|     14|OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
  |  |  ------------------
  |  |  |  | 3085|     14|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 14, False: 131]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|      0|OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  100|      0|OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  101|      0|OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  102|      0|OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  103|      0|OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  104|      0|OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  105|      0|OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  106|      0|OPCODE(OCLASS,     B)        /* R[a] = ::Object */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  107|      0|OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  108|      0|OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  109|      0|OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  110|      0|OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  111|      0|OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  112|      0|OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  113|      0|OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  114|      0|OPCODE(TCLASS,     B)        /* R[a] = target_class */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  115|      0|OPCODE(DEBUG,      BBB)      /* print a,b,c */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  116|      0|OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  117|      0|OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  118|      0|OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  119|      0|OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  120|      0|OPCODE(STOP,       Z)        /* stop VM */
  |  |  ------------------
  |  |  |  | 3085|      0|#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); mrb->c->ci->pc = pc; goto L_OP_ ## insn ## _BODY;
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (3085:26): [True: 0, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3087|    290|#undef OPCODE
 3088|    290|      }
 3089|      0|      pc--;
 3090|      0|      NEXT;
  ------------------
  |  | 1281|      0|#define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1260|      0|#define BYTECODE_DECODER(x) (x)
  |  |  ------------------
  |  |               #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
  |  |  ------------------
  |  |  |  | 1252|      0|#define CODE_FETCH_HOOK(mrb, irep, pc, regs) if ((mrb)->code_fetch_hook) (mrb)->code_fetch_hook((mrb), (irep), (pc), (regs));
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1252:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3091|      0|    }
 3092|       |
 3093|      0|    CASE(OP_STOP, Z) {
  ------------------
  |  | 1280|      0|#define CASE(insn,ops) L_ ## insn: pc++; FETCH_ ## ops (); mrb->c->ci->pc = pc; L_ ## insn ## _BODY:
  ------------------
 3094|       |      /*        stop VM */
 3095|  92.9k|      CHECKPOINT_RESTORE(RBREAK_TAG_STOP) {
  ------------------
  |  | 1237|      0|  do { \
  |  | 1238|      0|    if (FALSE) { \
  |  |  ------------------
  |  |  |  |   51|      0|#  define FALSE 0
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (51:17): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1239|  46.4k|      CHECKPOINT_LABEL_MAKE(tag): \
  |  |  ------------------
  |  |  |  | 1234|  46.4k|#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
  |  |  ------------------
  |  | 1240|  46.4k|      do {
  ------------------
 3096|       |        /* do nothing */
 3097|  92.9k|      }
 3098|  92.9k|      CHECKPOINT_MAIN(RBREAK_TAG_STOP) {
  ------------------
  |  | 1243|  46.4k|      } while (0); \
  |  |  ------------------
  |  |  |  Branch (1243:16): [Folded - Ignored]
  |  |  ------------------
  |  | 1244|  46.4k|    } \
  |  | 1245|  46.4k|    do {
  ------------------
 3099|  92.9k|        UNWIND_ENSURE(mrb, mrb->c->ci, pc, RBREAK_TAG_STOP, proc, mrb_nil_value());
  ------------------
  |  | 1211|  46.4k|  do { \
  |  | 1212|  46.4k|    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
  |  |  ------------------
  |  |  |  | 1098|  46.4k|#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
  |  |  ------------------
  |  | 1213|  46.4k|    if (ch) { \
  |  |  ------------------
  |  |  |  Branch (1213:9): [True: 0, False: 46.4k]
  |  |  ------------------
  |  | 1214|      0|      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
  |  |  ------------------
  |  |  |  | 1205|      0|  do { \
  |  |  |  | 1206|      0|    prepare_tagged_break(mrb, tag, proc, val); \
  |  |  |  | 1207|      0|    goto L_CATCH_TAGGED_BREAK; \
  |  |  |  | 1208|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1208:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1215|      0|    } \
  |  | 1216|  46.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1216:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3100|  92.9k|      }
 3101|  92.9k|      CHECKPOINT_END(RBREAK_TAG_STOP);
  ------------------
  |  | 1248|  46.4k|    } while (0); \
  |  |  ------------------
  |  |  |  Branch (1248:14): [Folded - Ignored]
  |  |  ------------------
  |  | 1249|  46.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1249:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3102|  46.9k|    L_STOP:
 3103|  46.9k|      mrb->jmp = prev_jmp;
 3104|  46.9k|      if (mrb->exc) {
  ------------------
  |  Branch (3104:11): [True: 443, False: 46.4k]
  ------------------
 3105|    443|        mrb_assert(mrb->exc->tt == MRB_TT_EXCEPTION);
  ------------------
  |  |   68|    443|#define mrb_assert(p) ((void)0)
  ------------------
 3106|    443|        return mrb_obj_value(mrb->exc);
 3107|    443|      }
 3108|  46.4k|      return regs[irep->nlocals];
  ------------------
  |  | 1335|  46.4k|#define regs (mrb->c->ci->stack)
  ------------------
 3109|  46.9k|    }
 3110|  46.9k|  }
 3111|      0|  END_DISPATCH;
 3112|      0|#undef regs
 3113|      0|  }
 3114|      0|  MRB_CATCH(&c_jmp) {
  ------------------
  |  |   45|      0|#define MRB_CATCH(buf) } else {
  ------------------
 3115|      0|    mrb_callinfo *ci = mrb->c->ci;
 3116|    526|    while (ci > mrb->c->cibase && ci->cci == CINFO_DIRECT) {
  ------------------
  |  |  336|    526|#define CINFO_DIRECT  2 // called method from C
  ------------------
  |  Branch (3116:12): [True: 526, False: 18.4E]
  |  Branch (3116:35): [True: 126, False: 400]
  ------------------
 3117|    126|      ci = cipop(mrb);
 3118|    126|    }
 3119|      0|    exc_catched = TRUE;
  ------------------
  |  |   54|      0|#  define TRUE 1
  ------------------
 3120|      0|    pc = ci->pc;
 3121|      0|    goto RETRY_TRY_BLOCK;
 3122|      0|  }
 3123|      0|  MRB_END_EXC(&c_jmp);
  ------------------
  |  |   46|      0|#define MRB_END_EXC(buf) }
  ------------------
 3124|      0|}
mrb_top_run:
 3134|  46.9k|{
 3135|  46.9k|  if (mrb->c->cibase && mrb->c->ci > mrb->c->cibase) {
  ------------------
  |  Branch (3135:7): [True: 45.1k, False: 1.74k]
  |  Branch (3135:25): [True: 0, False: 45.1k]
  ------------------
 3136|      0|    cipush(mrb, 0, CINFO_SKIP, mrb->object_class, NULL, NULL, 0, 0);
  ------------------
  |  |  335|      0|#define CINFO_SKIP    1 // ignited mruby VM from C
  ------------------
 3137|      0|  }
 3138|  46.9k|  return mrb_vm_run(mrb, proc, self, stack_keep);
 3139|  46.9k|}
vm.c:stack_extend:
  192|   531k|{
  193|   531k|  if (!mrb->c->ci->stack || mrb->c->ci->stack + room >= mrb->c->stend) {
  ------------------
  |  Branch (193:7): [True: 0, False: 531k]
  |  Branch (193:29): [True: 316, False: 531k]
  ------------------
  194|    316|    stack_extend_alloc(mrb, room);
  195|    316|  }
  196|   531k|}
vm.c:stack_extend_alloc:
  154|    316|{
  155|    316|  mrb_value *oldbase = mrb->c->stbase;
  156|    316|  mrb_value *newstack;
  157|    316|  size_t oldsize = mrb->c->stend - mrb->c->stbase;
  158|    316|  size_t size = oldsize;
  159|    316|  size_t off = mrb->c->ci->stack ? mrb->c->stend - mrb->c->ci->stack : 0;
  ------------------
  |  Branch (159:16): [True: 316, False: 0]
  ------------------
  160|       |
  161|    316|  if (off > size) size = off;
  ------------------
  |  Branch (161:7): [True: 0, False: 316]
  ------------------
  162|       |#ifdef MRB_STACK_EXTEND_DOUBLING
  163|       |  if ((size_t)room <= size)
  164|       |    size *= 2;
  165|       |  else
  166|       |    size += room;
  167|       |#else
  168|       |  /* Use linear stack growth.
  169|       |     It is slightly slower than doubling the stack space,
  170|       |     but it saves memory on small devices. */
  171|    316|  if (room <= MRB_STACK_GROWTH)
  ------------------
  |  |   40|    316|#define MRB_STACK_GROWTH 128
  ------------------
  |  Branch (171:7): [True: 4, False: 312]
  ------------------
  172|      4|    size += MRB_STACK_GROWTH;
  ------------------
  |  |   40|      4|#define MRB_STACK_GROWTH 128
  ------------------
  173|    312|  else
  174|    312|    size += room;
  175|    316|#endif
  176|       |
  177|    316|  newstack = (mrb_value*)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
  178|    316|  stack_clear(&(newstack[oldsize]), size - oldsize);
  179|    316|  envadjust(mrb, oldbase, newstack, oldsize);
  180|    316|  mrb->c->stbase = newstack;
  181|    316|  mrb->c->stend = mrb->c->stbase + size;
  182|       |
  183|       |  /* Raise an exception if the new stack size will be too large,
  184|       |     to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raise has stack space to work with. */
  185|    316|  if (size > MRB_STACK_MAX) {
  ------------------
  |  |   51|    316|#define MRB_STACK_MAX (0x40000 - MRB_STACK_GROWTH)
  |  |  ------------------
  |  |  |  |   40|    316|#define MRB_STACK_GROWTH 128
  |  |  ------------------
  ------------------
  |  Branch (185:7): [True: 0, False: 316]
  ------------------
  186|      0|    mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
  187|      0|  }
  188|    316|}
vm.c:envadjust:
  122|    316|{
  123|    316|  mrb_callinfo *ci = mrb->c->cibase;
  124|    316|  ptrdiff_t delta = newbase - oldbase;
  125|       |
  126|    316|  if (delta == 0) return;
  ------------------
  |  Branch (126:7): [True: 4, False: 312]
  ------------------
  127|    945|  while (ci <= mrb->c->ci) {
  ------------------
  |  Branch (127:10): [True: 633, False: 312]
  ------------------
  128|    633|    struct REnv *e = mrb_vm_ci_env(ci);
  129|    633|    mrb_value *st;
  130|       |
  131|    633|    if (e && MRB_ENV_ONSTACK_P(e) &&
  ------------------
  |  |   30|    633|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  |  |  |  Branch (30:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (131:9): [True: 0, False: 633]
  ------------------
  132|    633|        (st = e->stack) && (size_t)(st - oldbase) < oldsize) {
  ------------------
  |  Branch (132:9): [True: 0, False: 0]
  |  Branch (132:28): [True: 0, False: 0]
  ------------------
  133|      0|      e->stack += delta;
  134|      0|    }
  135|       |
  136|    633|    if (ci->proc && MRB_PROC_ENV_P(ci->proc) && e != MRB_PROC_ENV(ci->proc)) {
  ------------------
  |  |   72|  1.26k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  ------------------
  |  |  |  |   71|    631|#define MRB_PROC_ENVSET 1024
  |  |  ------------------
  |  |  |  Branch (72:27): [True: 0, False: 631]
  |  |  ------------------
  ------------------
                  if (ci->proc && MRB_PROC_ENV_P(ci->proc) && e != MRB_PROC_ENV(ci->proc)) {
  ------------------
  |  |   73|      0|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (136:9): [True: 631, False: 2]
  |  Branch (136:49): [True: 0, False: 0]
  ------------------
  137|      0|      e = MRB_PROC_ENV(ci->proc);
  ------------------
  |  |   73|      0|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|      0|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|      0|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  138|       |
  139|      0|      if (e && MRB_ENV_ONSTACK_P(e) &&
  ------------------
  |  |   30|      0|#define MRB_ENV_ONSTACK_P(e) (((e)->flags & MRB_ENV_CLOSED) == 0)
  |  |  ------------------
  |  |  |  |   28|      0|#define MRB_ENV_CLOSED (1<<20)
  |  |  ------------------
  |  |  |  Branch (30:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (139:11): [True: 0, False: 0]
  ------------------
  140|      0|          (st = e->stack) && (size_t)(st - oldbase) < oldsize) {
  ------------------
  |  Branch (140:11): [True: 0, False: 0]
  |  Branch (140:30): [True: 0, False: 0]
  ------------------
  141|      0|        e->stack += delta;
  142|      0|      }
  143|      0|    }
  144|       |
  145|    633|    ci->stack += delta;
  146|    633|    ci++;
  147|    633|  }
  148|    312|}
vm.c:ci_env_set:
  297|   952k|{
  298|   952k|  if (ci->u.env) {
  ------------------
  |  Branch (298:7): [True: 951k, False: 1.74k]
  ------------------
  299|   951k|    if (ci->u.env->tt == MRB_TT_ENV) {
  ------------------
  |  Branch (299:9): [True: 24.4k, False: 926k]
  ------------------
  300|  24.4k|      if (e) {
  ------------------
  |  Branch (300:11): [True: 0, False: 24.4k]
  ------------------
  301|      0|        e->c = ci->u.env->c;
  302|      0|        ci->u.env = e;
  303|      0|      }
  304|  24.4k|      else {
  305|  24.4k|        ci->u.target_class = ci->u.env->c;
  306|  24.4k|      }
  307|  24.4k|    }
  308|   926k|    else if (e) {
  ------------------
  |  Branch (308:14): [True: 0, False: 926k]
  ------------------
  309|      0|      e->c = ci->u.target_class;
  310|      0|      ci->u.env = e;
  311|      0|    }
  312|   951k|  }
  313|  1.74k|  else {
  314|  1.74k|    ci->u.env = e;
  315|  1.74k|  }
  316|   952k|}
vm.c:stack_copy:
   98|  85.2k|{
   99|  85.2k|  if (!src) return;
  ------------------
  |  Branch (99:7): [True: 1.75k, False: 83.5k]
  ------------------
  100|  83.5k|  memcpy(dst, src, sizeof(mrb_value)*size);
  101|  83.5k|}
vm.c:cipop:
  415|   905k|{
  416|   905k|  struct mrb_context *c = mrb->c;
  417|   905k|  mrb_callinfo *ci = c->ci;
  418|   905k|  struct REnv *env = CI_ENV(ci);
  ------------------
  |  |  287|   905k|#define CI_ENV(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env : NULL)
  |  |  ------------------
  |  |  |  Branch (287:22): [True: 904k, False: 1.74k]
  |  |  |  Branch (287:37): [True: 24.4k, False: 879k]
  |  |  ------------------
  ------------------
  419|       |
  420|   905k|  ci_env_set(ci, NULL); // make possible to free env by GC if not needed
  421|   905k|  struct RProc *b = ci->blk;
  422|   905k|  if (b && !mrb_object_dead_p(mrb, (struct RBasic*)b) && b->tt == MRB_TT_PROC &&
  ------------------
  |  Branch (422:7): [True: 24.4k, False: 881k]
  |  Branch (422:12): [True: 24.4k, False: 0]
  |  Branch (422:58): [True: 24.4k, False: 0]
  ------------------
  423|   905k|      !MRB_PROC_STRICT_P(b) && MRB_PROC_ENV(b) == CI_ENV(&ci[-1])) {
  ------------------
  |  |   68|   930k|#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
  |  |  ------------------
  |  |  |  |   67|  24.4k|#define MRB_PROC_STRICT 256
  |  |  ------------------
  ------------------
                    !MRB_PROC_STRICT_P(b) && MRB_PROC_ENV(b) == CI_ENV(&ci[-1])) {
  ------------------
  |  |   73|  24.4k|#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
  |  |  ------------------
  |  |  |  |   72|  24.4k|#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   71|  24.4k|#define MRB_PROC_ENVSET 1024
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (72:27): [True: 24.4k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                    !MRB_PROC_STRICT_P(b) && MRB_PROC_ENV(b) == CI_ENV(&ci[-1])) {
  ------------------
  |  |  287|  24.4k|#define CI_ENV(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env : NULL)
  |  |  ------------------
  |  |  |  Branch (287:22): [True: 24.4k, False: 0]
  |  |  |  Branch (287:37): [True: 24.4k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (423:7): [True: 24.4k, False: 0]
  |  Branch (423:32): [True: 24.4k, False: 0]
  ------------------
  424|  24.4k|    b->flags |= MRB_PROC_ORPHAN;
  ------------------
  |  |   69|  24.4k|#define MRB_PROC_ORPHAN 512
  ------------------
  425|  24.4k|  }
  426|   905k|  if (env && !mrb_env_unshare(mrb, env, TRUE)) {
  ------------------
  |  |   54|  24.4k|#  define TRUE 1
  ------------------
  |  Branch (426:7): [True: 24.4k, False: 881k]
  |  Branch (426:14): [True: 0, False: 24.4k]
  ------------------
  427|      0|    c->ci--; // exceptions are handled at the method caller; see #3087
  428|      0|    mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
  429|      0|  }
  430|   905k|  c->ci--;
  431|   905k|  return c->ci;
  432|   905k|}
vm.c:ci_bidx:
  539|   329k|{
  540|   329k|  return mrb_bidx(ci->n, ci->nk);
  541|   329k|}
vm.c:stack_init:
  105|  1.74k|{
  106|  1.74k|  struct mrb_context *c = mrb->c;
  107|       |
  108|       |  /* mrb_assert(mrb->stack == NULL); */
  109|  1.74k|  c->stbase = (mrb_value*)mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
  ------------------
  |  |   35|  1.74k|#define STACK_INIT_SIZE 128
  ------------------
  110|  1.74k|  c->stend = c->stbase + STACK_INIT_SIZE;
  ------------------
  |  |   35|  1.74k|#define STACK_INIT_SIZE 128
  ------------------
  111|       |
  112|       |  /* mrb_assert(ci == NULL); */
  113|  1.74k|  c->cibase = (mrb_callinfo*)mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
  ------------------
  |  |   36|  1.74k|#define CALLINFO_INIT_SIZE 32
  ------------------
  114|  1.74k|  c->ciend = c->cibase + CALLINFO_INIT_SIZE;
  ------------------
  |  |   36|  1.74k|#define CALLINFO_INIT_SIZE 32
  ------------------
  115|  1.74k|  c->ci = c->cibase;
  116|  1.74k|  c->ci->u.target_class = mrb->object_class;
  117|  1.74k|  c->ci->stack = c->stbase;
  118|  1.74k|}
vm.c:ensure_block:
  637|   193k|{
  638|   193k|  if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) {
  ------------------
  |  |  174|   387k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  ------------------
                if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) {
  ------------------
  |  |  197|  24.4k|#define mrb_proc_p(o) WORDBOX_OBJ_TYPE_P(o, PROC)
  |  |  ------------------
  |  |  |  |   78|  24.4k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  48.8k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  48.8k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 24.4k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 24.4k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 24.4k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (638:7): [True: 24.4k, False: 169k]
  ------------------
  639|      0|    blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc));
  ------------------
  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  640|       |    /* The stack might have been reallocated during mrb_type_convert(), see #3622 */
  641|      0|  }
  642|   193k|  return blk;
  643|   193k|}
vm.c:cipush:
  344|   905k|{
  345|   905k|  struct mrb_context *c = mrb->c;
  346|   905k|  mrb_callinfo *ci = c->ci;
  347|       |
  348|   905k|  if (ci + 1 == c->ciend) {
  ------------------
  |  Branch (348:7): [True: 0, False: 905k]
  ------------------
  349|      0|    ptrdiff_t size = ci - c->cibase;
  350|       |
  351|      0|    if (size > MRB_CALL_LEVEL_MAX) {
  ------------------
  |  |   45|      0|#define MRB_CALL_LEVEL_MAX 512
  ------------------
  |  Branch (351:9): [True: 0, False: 0]
  ------------------
  352|      0|      mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
  353|      0|    }
  354|      0|    c->cibase = (mrb_callinfo*)mrb_realloc(mrb, c->cibase, sizeof(mrb_callinfo)*size*2);
  355|      0|    c->ci = c->cibase + size;
  356|      0|    c->ciend = c->cibase + size * 2;
  357|      0|  }
  358|   905k|  ci = ++c->ci;
  359|   905k|  ci->mid = mid;
  360|   905k|  CI_PROC_SET(ci, proc);
  ------------------
  |  |  256|   905k|#define CI_PROC_SET(ci, p) do {\
  |  |  257|   905k|  ci->proc = p;\
  |  |  258|   905k|  ci->pc = (p && !MRB_PROC_CFUNC_P(p)) ? p->body.irep->iseq : NULL;\
  |  |  ------------------
  |  |  |  |   65|   123k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   123k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (258:13): [True: 123k, False: 781k]
  |  |  |  Branch (258:18): [True: 123k, False: 0]
  |  |  ------------------
  |  |  259|   905k|} while (0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  361|   905k|  ci->blk = blk;
  362|   905k|  ci->stack = ci[-1].stack + push_stacks;
  363|   905k|  ci->n = argc & 0xf;
  364|   905k|  ci->nk = (argc>>4) & 0xf;
  365|   905k|  ci->cci = cci;
  366|   905k|  ci->u.target_class = target_class;
  367|       |
  368|   905k|  return ci;
  369|   905k|}
vm.c:funcall_args_capture:
  609|  60.8k|{
  610|  60.8k|  if (argc < 0 || argc > INT32_MAX) {
  ------------------
  |  Branch (610:7): [True: 0, False: 60.8k]
  |  Branch (610:19): [True: 0, False: 60.8k]
  ------------------
  611|      0|    mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative or too big argc for funcall (%i)", argc);
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  612|      0|  }
  613|       |
  614|  60.8k|  ci->nk = 0;                   /* funcall does not support keyword arguments */
  615|  60.8k|  if (argc < CALL_MAXARGS) {
  ------------------
  |  |   84|  60.8k|#define CALL_MAXARGS 15
  ------------------
  |  Branch (615:7): [True: 60.8k, False: 0]
  ------------------
  616|  60.8k|    mrb_int extends = stoff + argc + 2 /* self + block */;
  617|  60.8k|    stack_extend_adjust(mrb, extends, &argv);
  618|       |
  619|  60.8k|    mrb_value *args = mrb->c->ci->stack + stoff + 1 /* self */;
  620|  60.8k|    stack_copy(args, argv, argc);
  621|  60.8k|    args[argc] = block;
  622|  60.8k|    ci->n = (uint8_t)argc;
  623|  60.8k|  }
  624|      0|  else {
  625|      0|    int extends = stoff + 3 /* self + splat + block */;
  626|      0|    stack_extend_adjust(mrb, extends, &argv);
  627|       |
  628|      0|    mrb_value *args = mrb->c->ci->stack + stoff + 1 /* self */;
  629|      0|    args[0] = mrb_ary_new_from_values(mrb, argc, argv);
  630|      0|    args[1] = block;
  631|      0|    ci->n = CALL_MAXARGS;
  ------------------
  |  |   84|      0|#define CALL_MAXARGS 15
  ------------------
  632|      0|  }
  633|  60.8k|}
vm.c:prepare_missing:
  567|    126|{
  568|    126|  mrb_sym missing = MRB_SYM(method_missing);
  ------------------
  |  |   18|    126|#define MRB_SYM(name) MRB_SYM__##name
  ------------------
  569|    126|  mrb_value *argv = &ci->stack[1];
  570|    126|  mrb_value args;
  571|    126|  mrb_method_t m;
  572|       |
  573|       |  /* pack positional arguments */
  574|    126|  if (ci->n == 15) args = argv[0];
  ------------------
  |  Branch (574:7): [True: 0, False: 126]
  ------------------
  575|    126|  else args = mrb_ary_new_from_values(mrb, ci->n, argv);
  576|       |
  577|    126|  if (mrb_func_basic_p(mrb, recv, missing, mrb_obj_missing)) {
  ------------------
  |  Branch (577:7): [True: 126, False: 0]
  ------------------
  578|    126|  method_missing:
  579|    126|    if (super) mrb_no_method_error(mrb, mid, args, "no superclass method '%n'", mid);
  ------------------
  |  Branch (579:9): [True: 0, False: 126]
  ------------------
  580|    126|    else mrb_method_missing(mrb, mid, recv, args);
  581|       |    /* not reached */
  582|    126|  }
  583|      0|  if (mid != missing) {
  ------------------
  |  Branch (583:7): [True: 0, False: 0]
  ------------------
  584|      0|    ci->u.target_class = mrb_class(mrb, recv);
  585|      0|  }
  586|      0|  m = mrb_vm_find_method(mrb, ci->u.target_class, &ci->u.target_class, missing);
  587|      0|  if (MRB_METHOD_UNDEF_P(m)) goto method_missing; /* just in case */
  ------------------
  |  |  115|      0|#define MRB_METHOD_UNDEF_P(m) ((m)==0)
  |  |  ------------------
  |  |  |  Branch (115:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  588|      0|  stack_extend(mrb, 4);
  589|       |
  590|      0|  argv = &ci->stack[1];         /* maybe reallocated */
  591|      0|  argv[0] = args;
  592|      0|  if (ci->nk == 0) {
  ------------------
  |  Branch (592:7): [True: 0, False: 0]
  ------------------
  593|      0|    argv[1] = blk;
  594|      0|  }
  595|      0|  else {
  596|      0|    mrb_assert(ci->nk == 15);
  ------------------
  |  |   68|      0|#define mrb_assert(p) ((void)0)
  ------------------
  597|      0|    argv[1] = argv[ci->n];
  598|      0|    argv[2] = blk;
  599|      0|  }
  600|      0|  ci->n = CALL_MAXARGS;
  ------------------
  |  |   84|      0|#define CALL_MAXARGS 15
  ------------------
  601|       |  /* ci->nk is already set to zero or CALL_MAXARGS */
  602|      0|  mrb_ary_unshift(mrb, args, mrb_symbol_value(mid));
  603|      0|  ci->mid = missing;
  604|      0|  return m;
  605|      0|}
vm.c:check_method_noarg:
  718|   136k|{
  719|   136k|  mrb_int argc = ci->n == CALL_MAXARGS ? RARRAY_LEN(ci->stack[1]) : ci->n;
  ------------------
  |  |   84|   136k|#define CALL_MAXARGS 15
  ------------------
                mrb_int argc = ci->n == CALL_MAXARGS ? RARRAY_LEN(ci->stack[1]) : ci->n;
  ------------------
  |  |   72|  1.74k|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|  1.74k|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  1.74k|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  1.74k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 1.74k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|  1.74k|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|  1.74k|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (719:18): [True: 1.74k, False: 134k]
  ------------------
  720|   136k|  if (ci->nk > 0) {
  ------------------
  |  Branch (720:7): [True: 1.74k, False: 134k]
  ------------------
  721|  1.74k|    mrb_value kdict = ci->stack[mrb_ci_kidx(ci)];
  722|  1.74k|    if (!(mrb_hash_p(kdict) && mrb_hash_empty_p(mrb, kdict))) {
  ------------------
  |  |  188|  1.74k|#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
  |  |  ------------------
  |  |  |  |   78|  3.49k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.49k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.49k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 1.74k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.74k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 1.74k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (722:32): [True: 1.74k, False: 0]
  ------------------
  723|      0|      argc++;
  724|      0|    }
  725|  1.74k|  }
  726|   136k|  if (argc > 0) {
  ------------------
  |  Branch (726:7): [True: 9, False: 136k]
  ------------------
  727|      9|    mrb_argnum_error(mrb, argc, 0, 0);
  728|      9|  }
  729|   136k|}
vm.c:eval_under:
  889|  1.74k|{
  890|  1.74k|  struct RProc *p;
  891|  1.74k|  mrb_callinfo *ci;
  892|  1.74k|  int nregs;
  893|       |
  894|  1.74k|  check_block(mrb, blk);
  895|  1.74k|  ci = mrb->c->ci;
  896|  1.74k|  if (ci->cci == CINFO_DIRECT) {
  ------------------
  |  |  336|  1.74k|#define CINFO_DIRECT  2 // called method from C
  ------------------
  |  Branch (896:7): [True: 0, False: 1.74k]
  ------------------
  897|      0|    return mrb_yield_with_class(mrb, blk, 1, &self, self, c);
  898|      0|  }
  899|  1.74k|  ci->u.target_class = c;
  900|  1.74k|  p = mrb_proc_ptr(blk);
  ------------------
  |  |   90|  1.74k|#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
  |  |  ------------------
  |  |  |  |  150|  1.74k|#define mrb_ptr(o)     mrb_val_union(o).p
  |  |  ------------------
  ------------------
  901|  1.74k|  CI_PROC_SET(ci, p);
  ------------------
  |  |  256|  1.74k|#define CI_PROC_SET(ci, p) do {\
  |  |  257|  1.74k|  ci->proc = p;\
  |  |  258|  1.74k|  ci->pc = (p && !MRB_PROC_CFUNC_P(p)) ? p->body.irep->iseq : NULL;\
  |  |  ------------------
  |  |  |  |   65|  1.74k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  1.74k|#define MRB_PROC_CFUNC_FL 128
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (258:13): [True: 1.74k, False: 0]
  |  |  |  Branch (258:18): [True: 1.74k, False: 0]
  |  |  ------------------
  |  |  259|  1.74k|} while (0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  902|  1.74k|  ci->n = 1;
  903|  1.74k|  ci->nk = 0;
  904|  1.74k|  ci->mid = ci[-1].mid;
  905|  1.74k|  if (MRB_PROC_CFUNC_P(p)) {
  ------------------
  |  |   65|  1.74k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|  1.74k|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  |  |  |  Branch (65:29): [True: 0, False: 1.74k]
  |  |  ------------------
  ------------------
  906|      0|    stack_extend(mrb, 4);
  907|      0|    mrb->c->ci->stack[0] = self;
  908|      0|    mrb->c->ci->stack[1] = self;
  909|      0|    mrb->c->ci->stack[2] = mrb_nil_value();
  910|      0|    return MRB_PROC_CFUNC(p)(mrb, self);
  ------------------
  |  |   66|      0|#define MRB_PROC_CFUNC(p) (p)->body.func
  ------------------
  911|      0|  }
  912|  1.74k|  nregs = p->body.irep->nregs;
  913|  1.74k|  if (nregs < 4) nregs = 4;
  ------------------
  |  Branch (913:7): [True: 0, False: 1.74k]
  ------------------
  914|  1.74k|  stack_extend(mrb, nregs);
  915|  1.74k|  mrb->c->ci->stack[0] = self;
  916|  1.74k|  mrb->c->ci->stack[1] = self;
  917|  1.74k|  stack_clear(mrb->c->ci->stack+2, nregs-2);
  918|  1.74k|  ci = cipush(mrb, 0, 0, NULL, NULL, NULL, 0, 0);
  919|       |
  920|  1.74k|  return self;
  921|  1.74k|}
vm.c:check_block:
  878|  1.74k|{
  879|  1.74k|  if (mrb_nil_p(blk)) {
  ------------------
  |  |  174|  1.74k|#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
  |  |  ------------------
  |  |  |  Branch (174:23): [True: 0, False: 1.74k]
  |  |  ------------------
  ------------------
  880|      0|    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
  ------------------
  |  | 1377|      0|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  881|      0|  }
  882|  1.74k|  if (!mrb_proc_p(blk)) {
  ------------------
  |  |  197|  1.74k|#define mrb_proc_p(o) WORDBOX_OBJ_TYPE_P(o, PROC)
  |  |  ------------------
  |  |  |  |   78|  1.74k|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|  3.49k|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|  3.49k|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 1.74k]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 1.74k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 1.74k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  883|      0|    mrb_raise(mrb, E_TYPE_ERROR, "not a block");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  884|      0|  }
  885|  1.74k|}
vm.c:stack_extend_adjust:
  206|  60.8k|{
  207|  60.8k|  const struct mrb_context *c = mrb->c;
  208|  60.8k|  ptrdiff_t voff = *argp - c->stbase;
  209|       |
  210|  60.8k|  if (voff < 0 || voff >= c->stend - c->stbase) {
  ------------------
  |  Branch (210:7): [True: 1.75k, False: 59.0k]
  |  Branch (210:19): [True: 59.0k, False: 0]
  ------------------
  211|  60.8k|    stack_extend(mrb, room);
  212|  60.8k|  }
  213|      0|  else {
  214|      0|    stack_extend(mrb, room);
  215|      0|    *argp = c->stbase + voff;
  216|      0|  }
  217|  60.8k|}
vm.c:stack_clear:
   89|   316k|{
   90|  1.38M|  while (count-- > 0) {
  ------------------
  |  Branch (90:10): [True: 1.06M, False: 316k]
  ------------------
   91|  1.06M|    SET_NIL_VALUE(*from);
  ------------------
  |  |  210|  1.06M|#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
  ------------------
   92|  1.06M|    from++;
   93|  1.06M|  }
   94|   316k|}
vm.c:catch_handler_find:
 1103|   448k|{
 1104|   448k|  const mrb_irep *irep;
 1105|   448k|  ptrdiff_t xpc;
 1106|   448k|  size_t cnt;
 1107|   448k|  const struct mrb_irep_catch_handler *e;
 1108|       |
 1109|       |/* The comparison operators use `>` and `<=` because pc already points to the next instruction */
 1110|   448k|#define catch_cover_p(pc, beg, end) ((pc) > (ptrdiff_t)(beg) && (pc) <= (ptrdiff_t)(end))
 1111|       |
 1112|   448k|  if (ci->proc == NULL || MRB_PROC_CFUNC_P(ci->proc)) return NULL;
  ------------------
  |  |   65|   447k|#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
  |  |  ------------------
  |  |  |  |   64|   447k|#define MRB_PROC_CFUNC_FL 128
  |  |  ------------------
  |  |  |  Branch (65:29): [True: 0, False: 447k]
  |  |  ------------------
  ------------------
  |  Branch (1112:7): [True: 259, False: 447k]
  ------------------
 1113|   447k|  irep = ci->proc->body.irep;
 1114|   447k|  if (irep->clen < 1) return NULL;
  ------------------
  |  Branch (1114:7): [True: 442k, False: 5.23k]
  ------------------
 1115|  5.23k|  xpc = pc - irep->iseq;
 1116|       |  /* If it retry at the top level, pc will be 0, so check with -1 as the start position */
 1117|  5.23k|  mrb_assert(catch_cover_p(xpc, -1, irep->ilen));
  ------------------
  |  |   68|  5.23k|#define mrb_assert(p) ((void)0)
  ------------------
 1118|  5.23k|  if (!catch_cover_p(xpc, -1, irep->ilen)) return NULL;
  ------------------
  |  | 1110|  5.23k|#define catch_cover_p(pc, beg, end) ((pc) > (ptrdiff_t)(beg) && (pc) <= (ptrdiff_t)(end))
  |  |  ------------------
  |  |  |  Branch (1110:38): [True: 5.23k, False: 0]
  |  |  |  Branch (1110:65): [True: 5.23k, False: 0]
  |  |  ------------------
  ------------------
 1119|       |
 1120|       |  /* Currently uses a simple linear search to avoid processing complexity. */
 1121|  5.23k|  cnt = irep->clen;
 1122|  5.23k|  e = mrb_irep_catch_handler_table(irep) + cnt - 1;
 1123|  15.7k|  for (; cnt > 0; cnt --, e --) {
  ------------------
  |  Branch (1123:10): [True: 10.4k, False: 5.23k]
  ------------------
 1124|  10.4k|    if (((UINT32_C(1) << e->type) & filter) &&
  ------------------
  |  Branch (1124:9): [True: 5.23k, False: 5.23k]
  ------------------
 1125|  10.4k|        catch_cover_p(xpc, mrb_irep_catch_handler_unpack(e->begin), mrb_irep_catch_handler_unpack(e->end))) {
  ------------------
  |  | 1110|  5.23k|#define catch_cover_p(pc, beg, end) ((pc) > (ptrdiff_t)(beg) && (pc) <= (ptrdiff_t)(end))
  |  |  ------------------
  |  |  |  Branch (1110:38): [True: 0, False: 5.23k]
  |  |  |  Branch (1110:65): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1126|      0|      return e;
 1127|      0|    }
 1128|  10.4k|  }
 1129|       |
 1130|  5.23k|#undef catch_cover_p
 1131|       |
 1132|  5.23k|  return NULL;
 1133|  5.23k|}
vm.c:mrb_bidx:
  530|  1.04M|{
  531|  1.04M|  if (n == 15) n = 1;
  ------------------
  |  Branch (531:7): [True: 167k, False: 881k]
  ------------------
  532|  1.04M|  if (k == 15) n += 1;
  ------------------
  |  Branch (532:7): [True: 89.9k, False: 958k]
  ------------------
  533|   958k|  else n += k*2;
  534|  1.04M|  return n + 1;                 /* self + args + kargs */
  535|  1.04M|}
vm.c:mrb_gc_arena_shrink:
   64|   443k|{
   65|   443k|  mrb_gc *gc = &mrb->gc;
   66|   443k|  int capa = gc->arena_capa;
   67|       |
   68|   443k|  gc->arena_idx = idx;
   69|   443k|  if (idx < capa / 4) {
  ------------------
  |  Branch (69:7): [True: 443k, False: 0]
  ------------------
   70|   443k|    capa >>= 2;
   71|   443k|    if (capa < MRB_GC_ARENA_SIZE) {
  ------------------
  |  |   28|   443k|#define MRB_GC_ARENA_SIZE 100
  ------------------
  |  Branch (71:9): [True: 443k, False: 44]
  ------------------
   72|   443k|      capa = MRB_GC_ARENA_SIZE;
  ------------------
  |  |   28|   443k|#define MRB_GC_ARENA_SIZE 100
  ------------------
   73|   443k|    }
   74|   443k|    if (capa != gc->arena_capa) {
  ------------------
  |  Branch (74:9): [True: 131, False: 443k]
  ------------------
   75|    131|      gc->arena = (struct RBasic**)mrb_realloc(mrb, gc->arena, sizeof(struct RBasic*)*capa);
   76|    131|      gc->arena_capa = capa;
   77|    131|    }
   78|   443k|  }
   79|   443k|}
vm.c:argnum_error:
 1168|     43|{
 1169|     43|  mrb_value exc;
 1170|     43|  mrb_value str;
 1171|     43|  mrb_int argc = mrb->c->ci->n;
 1172|       |
 1173|     43|  if (argc == 15) {
  ------------------
  |  Branch (1173:7): [True: 0, False: 43]
  ------------------
 1174|      0|    mrb_value args = mrb->c->ci->stack[1];
 1175|      0|    if (mrb_array_p(args)) {
  ------------------
  |  |  186|      0|#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
  |  |  ------------------
  |  |  |  |   78|      0|  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
  |  |  |  |  ------------------
  |  |  |  |  |  |  148|      0|#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   71|      0|#define WORDBOX_IMMEDIATE_MASK  0x07
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (148:29): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (148:63): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (78:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1176|      0|      argc = RARRAY_LEN(args);
  ------------------
  |  |   72|      0|#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
  |  |  ------------------
  |  |  |  |   70|      0|#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:24): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
  |  |  |  |  ------------------
  |  |  |  |  |  |   65|      0|#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   62|      0|#define MRB_ARY_EMBED_MASK  7
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1177|      0|    }
 1178|      0|  }
 1179|     43|  if (argc == 0 && mrb->c->ci->nk != 0 && !mrb_hash_empty_p(mrb, mrb->c->ci->stack[1])) {
  ------------------
  |  Branch (1179:7): [True: 0, False: 43]
  |  Branch (1179:20): [True: 0, False: 0]
  |  Branch (1179:43): [True: 0, False: 0]
  ------------------
 1180|      0|    argc++;
 1181|      0|  }
 1182|     43|  str = mrb_format(mrb, "wrong number of arguments (given %i, expected %i)", argc, num);
 1183|     43|  exc = mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str);
  ------------------
  |  | 1377|     43|#define E_ARGUMENT_ERROR     mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError))
  |  |  ------------------
  |  |  |  |   35|     43|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|     43|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1184|     43|  mrb_exc_set(mrb, exc);
 1185|     43|}
vm.c:mrb_ci_kidx:
  523|  37.9k|{
  524|  37.9k|  if (ci->nk == 0) return -1;
  ------------------
  |  Branch (524:7): [True: 0, False: 37.9k]
  ------------------
  525|  37.9k|  return (ci->n == CALL_MAXARGS) ? 2 : ci->n + 1;
  ------------------
  |  |   84|  37.9k|#define CALL_MAXARGS 15
  ------------------
  |  Branch (525:10): [True: 37.9k, False: 0]
  ------------------
  526|  37.9k|}
vm.c:ary_new_from_regs:
 1350|  86.2k|{
 1351|  86.2k|  mrb_value ary = mrb_ary_new_capa(mrb, argc);
 1352|   305k|  while (argc--) {
  ------------------
  |  Branch (1352:10): [True: 219k, False: 86.2k]
  ------------------
 1353|   219k|    mrb_ary_push(mrb, ary, regs[idx]);
  ------------------
  |  | 1335|   219k|#define regs (mrb->c->ci->stack)
  ------------------
 1354|   219k|    idx++;
 1355|   219k|  }
 1356|  86.2k|  return ary;
 1357|  86.2k|}
vm.c:check_target_class:
 1327|   832k|{
 1328|   832k|  struct RClass *target = CI_TARGET_CLASS(mrb->c->ci);
  ------------------
  |  |  267|   832k|#define CI_TARGET_CLASS(ci) (((ci)->u.env && (ci)->u.env->tt == MRB_TT_ENV)? (ci)->u.env->c : (ci)->u.target_class)
  |  |  ------------------
  |  |  |  Branch (267:31): [True: 832k, False: 0]
  |  |  |  Branch (267:46): [True: 1.74k, False: 830k]
  |  |  ------------------
  ------------------
 1329|   832k|  if (!target) {
  ------------------
  |  Branch (1329:7): [True: 0, False: 832k]
  ------------------
 1330|      0|    mrb_raise(mrb, E_TYPE_ERROR, "no class/module to add method");
  ------------------
  |  | 1375|      0|#define E_TYPE_ERROR         mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError))
  |  |  ------------------
  |  |  |  |   35|      0|#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
  |  |  |  |  ------------------
  |  |  |  |  |  |   18|      0|#define MRB_SYM(name) MRB_SYM__##name
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1331|      0|  }
 1332|   832k|  return target;
 1333|   832k|}
vm.c:mrb_run:
 3128|     21|{
 3129|     21|  return mrb_vm_run(mrb, proc, self, ci_bidx(mrb->c->ci) + 1);
 3130|     21|}