p6.p6

my int $MVM_reg_void            := 0; # not really a register; just a result/return kind marker
my int $MVM_reg_int8            := 1;
my int $MVM_reg_int16           := 2;
my int $MVM_reg_int32           := 3;
my int $MVM_reg_int64           := 4;
my int $MVM_reg_num32           := 5;
my int $MVM_reg_num64           := 6;
my int $MVM_reg_str             := 7;
my int $MVM_reg_obj             := 8;
my int $MVM_reg_uint8           := 17;
my int $MVM_reg_uint16          := 18;
my int $MVM_reg_uint32          := 19;
my int $MVM_reg_uint64          := 20;

my int $MVM_operand_int8        := ($MVM_reg_int8 * 8);
my int $MVM_operand_int16       := ($MVM_reg_int16 * 8);
my int $MVM_operand_int32       := ($MVM_reg_int32 * 8);
my int $MVM_operand_int64       := ($MVM_reg_int64 * 8);
my int $MVM_operand_num32       := ($MVM_reg_num32 * 8);
my int $MVM_operand_num64       := ($MVM_reg_num64 * 8);
my int $MVM_operand_str         := ($MVM_reg_str * 8);
my int $MVM_operand_obj         := ($MVM_reg_obj * 8);
my int $MVM_operand_ins         := (9 * 8);
my int $MVM_operand_type_var    := (10 * 8);
my int $MVM_operand_lex_outer   := (11 * 8);
my int $MVM_operand_coderef     := (12 * 8);
my int $MVM_operand_callsite    := (13 * 8);
my int $MVM_operand_type_mask   := (31 * 8);
my int $MVM_operand_uint8       := ($MVM_reg_uint8 * 8);
my int $MVM_operand_uint16      := ($MVM_reg_uint16 * 8);
my int $MVM_operand_uint32      := ($MVM_reg_uint32 * 8);
my int $MVM_operand_uint64      := ($MVM_reg_uint64 * 8);

sub resolve_condition_op($kind, $negated) {
    return $negated ??
        $kind == $MVM_reg_obj    ?? 'unless_o' !!
        $kind == $MVM_reg_int64  ?? 'unless_i' !!
        $kind == $MVM_reg_str    ?? 'unless_s' !!
        $kind == $MVM_reg_num64  ?? 'unless_n' !!
        $kind == $MVM_reg_int64  ?? 'unless_i' !!
        $kind == $MVM_reg_uint64 ?? 'unless_i' !!
        $kind == $MVM_reg_int32  ?? 'unless_i' !!
        $kind == $MVM_reg_num32  ?? 'unless_n' !!
        $kind == $MVM_reg_uint32 ?? 'unless_i' !!
        $kind == $MVM_reg_int8   ?? 'unless_i' !!
        $kind == $MVM_reg_uint8  ?? 'unless_i' !!
        $kind == $MVM_reg_int16  ?? 'unless_i' !!
        $kind == $MVM_reg_uint16 ?? 'unless_i' !!
        nqp::die("Unhandled kind $kind")
     !! $kind == $MVM_reg_int64 ?? 'if_i' !!
        $kind == $MVM_reg_num64 ?? 'if_n' !!
        $kind == $MVM_reg_str   ?? 'if_s0' !!
        $kind == $MVM_reg_obj   ?? 'if_o' !!
        nqp::die("Unhandled kind $kind")
}

my @Condition-op-kinds := nqp::list(
    nqp::null,  'if_i',     # $MVM_reg_void,   $MVM_reg_int8
    'if_i',     'if_i',     # $MVM_reg_int16,  $MVM_reg_int32
    'if_i',     'if_n',     # $MVM_reg_int64,  $MVM_reg_num32
    'if_n',     'if_s',     # $MVM_reg_num64,  $MVM_reg_str
    'if_o',                 # $MVM_reg_obj
    nqp::null, nqp::null, nqp::null, nqp::null,
    nqp::null, nqp::null, nqp::null, nqp::null,
    'if_i',                 # $MVM_reg_uint8
    'if_i',     'if_i',     # $MVM_reg_uint16, $MVM_reg_uint32
    'if_i',                 # $MVM_reg_uint64
);
my @Negated-condition-op-kinds := nqp::list(
    nqp::null,  'unless_i', # $MVM_reg_void,   $MVM_reg_int8
    'unless_i', 'unless_i', # $MVM_reg_int16,  $MVM_reg_int32
    'unless_i', 'unless_n', # $MVM_reg_int64,  $MVM_reg_num32
    'unless_n', 'unless_s', # $MVM_reg_num64,  $MVM_reg_str
    'unless_o',             # $MVM_reg_obj,
    nqp::null, nqp::null, nqp::null, nqp::null,
    nqp::null, nqp::null, nqp::null, nqp::null,
    'unless_i', 'unless_i', # $MVM_reg_uint8,  $MVM_reg_uint16
    'unless_i', 'unless_i', # $MVM_reg_uint32, $MVM_reg_uint64
);
my @Full-width-coerce-to := nqp::list( # 0 means we don't need any coersion
    0,              $MVM_reg_int64, # $MVM_reg_void,   $MVM_reg_int8
    $MVM_reg_int64, $MVM_reg_int64, # $MVM_reg_int16,  $MVM_reg_int32
    0,              $MVM_reg_num64, # $MVM_reg_int64,  $MVM_reg_num32
    0,              0,              # $MVM_reg_num64,  $MVM_reg_str
    0,                              # $MVM_reg_obj
    0, 0, 0, 0,   0, 0, 0, 0,
    $MVM_reg_int64, $MVM_reg_int64, # $MVM_reg_uint8,  $MVM_reg_uint16
    $MVM_reg_int64, $MVM_reg_int64, # $MVM_reg_uint32, $MVM_reg_uint64
);

my $i := 0;
my $r := $MVM_reg_uint16;
my $neg := 1;
my $kind := 8;
while $i++ < 1000_000 {
    # $neg   ?? nqp::atpos_s(@negated-condition-op-kinds, $kind)
    #        !! nqp::atpos_s(@condition-op-kinds, $kind);
    # !$neg  ?? nqp::atpos_s(@negated-condition-op-kinds, $kind)
    #        !! nqp::atpos_s(@condition-op-kinds, $kind);
    $neg   ?? @Negated-condition-op-kinds[$kind]
           !! @Condition-op-kinds[$kind];
    !$neg  ?? @Negated-condition-op-kinds[$kind]
           !! @Condition-op-kinds[$kind];
    # resolve_condition_op($kind, $neg);
    # resolve_condition_op($kind, $neg);
    @Full-width-coerce-to[$kind];
}
  my $_ := 17;
   say(@Condition-op-kinds[$_]);
   say(@Negated-condition-op-kinds[$_]);
   say(@Full-width-coerce-to[$_]);