beam_hot.h

/*
 *  Warning: Do not edit this file.
 *  Auto-generated by 'beam_makeops'.
 */

OpCase(allocate_heap_III):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    AllocateHeap(Arg(0), Arg(1), Arg(2));
    NextPF(3, next);
    }

OpCase(allocate_heap_zero_III):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    AllocateHeapZero(Arg(0), Arg(1), Arg(2));
    NextPF(3, next);
    }

OpCase(allocate_init_tIy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    AllocateInit(tb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(allocate_tt):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Allocate(tb(tmp_packed1&BEAM_LOOSE_MASK), tb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(allocate_zero_tt):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    AllocateZero(tb(tmp_packed1&BEAM_LOOSE_MASK), tb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(deallocate_return_P):
    DeallocateReturn(Arg(0));

OpCase(extract_next_element2_x):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    ExtractNextElement2(xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(extract_next_element2_y):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    ExtractNextElement2(yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(extract_next_element3_x):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    ExtractNextElement3(xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(extract_next_element3_y):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    ExtractNextElement3(yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(extract_next_element_x):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    ExtractNextElement(xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(extract_next_element_y):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    ExtractNextElement(yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(get_list_rrx):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    GetList(r(0), r(0), xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(get_list_rry):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    GetList(r(0), r(0), yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(get_list_rxr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    GetList(r(0), xb(Arg(0)), r(0));
    NextPF(1, next);
    }

OpCase(get_list_rxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(r(0), xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_rxy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(r(0), xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_ryr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    GetList(r(0), yb(Arg(0)), r(0));
    NextPF(1, next);
    }

OpCase(get_list_ryx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(r(0), yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_ryy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(r(0), yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_xrx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_LOOSE_MASK), r(0), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_xry):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_LOOSE_MASK), r(0), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_xxr):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), r(0));
    NextPF(1, next);
    }

OpCase(get_list_xxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_TIGHT_MASK), xb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_xxy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_TIGHT_MASK), xb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), yb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_xyr):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), r(0));
    NextPF(1, next);
    }

OpCase(get_list_xyx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_xyy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(xb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), yb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_yrx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_LOOSE_MASK), r(0), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_yry):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_LOOSE_MASK), r(0), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(get_list_yxr):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), r(0));
    NextPF(1, next);
    }

OpCase(get_list_yxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_TIGHT_MASK), xb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_yxy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_TIGHT_MASK), xb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), yb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_yyr):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), r(0));
    NextPF(1, next);
    }

OpCase(get_list_yyx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(get_list_yyy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    GetList(yb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), yb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(i_fetch_cc):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    FetchArgs(Arg(0), Arg(1));
    NextPF(2, next);
    }

OpCase(i_fetch_cr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    FetchArgs(Arg(0), r(0));
    NextPF(1, next);
    }

OpCase(i_fetch_cx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    FetchArgs(Arg(0), xb(Arg(1)));
    NextPF(2, next);
    }

OpCase(i_fetch_cy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    FetchArgs(Arg(0), yb(Arg(1)));
    NextPF(2, next);
    }

OpCase(i_fetch_rc):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    FetchArgs(r(0), Arg(0));
    NextPF(1, next);
    }

OpCase(i_fetch_rx):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    FetchArgs(r(0), xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(i_fetch_ry):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    FetchArgs(r(0), yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(i_fetch_xc):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    FetchArgs(xb(Arg(0)), Arg(1));
    NextPF(2, next);
    }

OpCase(i_fetch_xr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    FetchArgs(xb(Arg(0)), r(0));
    NextPF(1, next);
    }

OpCase(i_fetch_xx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    FetchArgs(xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(i_fetch_xy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    FetchArgs(xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(i_fetch_yc):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    FetchArgs(yb(Arg(0)), Arg(1));
    NextPF(2, next);
    }

OpCase(i_fetch_yr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    FetchArgs(yb(Arg(0)), r(0));
    NextPF(1, next);
    }

OpCase(i_fetch_yx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    FetchArgs(yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(i_fetch_yy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    FetchArgs(yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(i_get_tuple_element_rPx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    GetTupleElement(r(0), Arg(0), xb(Arg(1)));
    NextPF(2, next);
    }

OpCase(i_get_tuple_element_xPr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    GetTupleElement(xb(Arg(0)), Arg(1), r(0));
    NextPF(2, next);
    }

OpCase(i_get_tuple_element_xPx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    GetTupleElement(xb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(i_get_tuple_element_yPr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    GetTupleElement(yb(Arg(0)), Arg(1), r(0));
    NextPF(2, next);
    }

OpCase(i_get_tuple_element_yPx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    GetTupleElement(yb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(i_is_eq_immed_frc):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    EqualImmed(r(0), Arg(1), ClauseFail());
    NextPF(2, next);
    }

OpCase(i_is_eq_immed_fxc):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    EqualImmed(xb(Arg(1)), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(i_is_eq_immed_fyc):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    EqualImmed(yb(Arg(1)), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(i_put_tuple_Acr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutTuple(Arg(0), Arg(1), r(0));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Acx):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    PutTuple(Arg(0), Arg(1), xb(Arg(2)));
    NextPF(3, next);
    }

OpCase(i_put_tuple_Anr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutTuple(Arg(0), NIL, r(0));
    NextPF(1, next);
    }

OpCase(i_put_tuple_Anx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutTuple(Arg(0), NIL, xb(Arg(1)));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Arx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutTuple(Arg(0), r(0), xb(Arg(1)));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Axr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutTuple(Arg(0), xb(Arg(1)), r(0));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Axx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutTuple(Arg(0), xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Axy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutTuple(Arg(0), xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Ayr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutTuple(Arg(0), yb(Arg(1)), r(0));
    NextPF(2, next);
    }

OpCase(i_put_tuple_Ayx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutTuple(Arg(0), yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(init2_yy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Init2(yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)));
    NextPF(1, next);
    }

OpCase(init3_yyy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Init3(yb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), yb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK));
    NextPF(1, next);
    }

OpCase(is_atom_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsAtom(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_atom_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsAtom(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_binary_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsBinary(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_binary_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsBinary(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_bitstring_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsBitstring(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_bitstring_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsBitstring(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_float_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsFloat(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_float_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsFloat(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_function2_fss):
    { Eterm targ1; Eterm targ2; 
    BeamInstr* next;
    PreFetch(3, next);
    GetR(1, targ1);
    GetR(2, targ2);
    IsFunction2(targ1, targ2, ClauseFail());
    NextPF(3, next);
    }

OpCase(is_function_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsFunction(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_function_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsFunction(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_function_fy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsFunction(yb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_integer_allocate_frII):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsIntegerAllocate(r(0), Arg(1), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(is_integer_allocate_fxII):
    { 
    BeamInstr* next;
    PreFetch(4, next);
    IsIntegerAllocate(xb(Arg(1)), Arg(2), Arg(3), ClauseFail());
    NextPF(4, next);
    }

OpCase(is_integer_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsInteger(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_integer_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsInteger(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_integer_fy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsInteger(yb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_list_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsList(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_list_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsList(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_nil_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsNil(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_nil_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsNil(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_nil_fy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsNil(yb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_non_empty_list_test_heap_frII):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsNonemptyListTestHeap(r(0), Arg(1), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(is_nonempty_list_allocate_frII):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsNonemptyListAllocate(r(0), Arg(1), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(is_nonempty_list_allocate_fxII):
    { 
    BeamInstr* next;
    PreFetch(4, next);
    IsNonemptyListAllocate(xb(Arg(1)), Arg(2), Arg(3), ClauseFail());
    NextPF(4, next);
    }

OpCase(is_nonempty_list_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsNonemptyList(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_nonempty_list_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsNonemptyList(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_nonempty_list_fy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsNonemptyList(yb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_pid_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsPid(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_pid_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsPid(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_port_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsPort(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_port_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsPort(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_reference_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsRef(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_reference_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsRef(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_tuple_fr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    IsTuple(r(0), ClauseFail());
    NextPF(1, next);
    }

OpCase(is_tuple_fx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsTuple(xb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_tuple_fy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsTuple(yb(Arg(1)), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_tuple_of_arity_frA):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsTupleOfArity(r(0), Arg(1), ClauseFail());
    NextPF(2, next);
    }

OpCase(is_tuple_of_arity_fxA):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsTupleOfArity(xb(Arg(1)), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(is_tuple_of_arity_fyA):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsTupleOfArity(yb(Arg(1)), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(move2_xyxy):
    { BeamInstr tmp_packed1;BeamInstr tmp_packed2;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    tmp_packed2 = Arg(1);
    Move2(xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), xb(tmp_packed2&BEAM_LOOSE_MASK), yb((tmp_packed2>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(move2_yxyx):
    { BeamInstr tmp_packed1;BeamInstr tmp_packed2;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    tmp_packed2 = Arg(1);
    Move2(yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), yb(tmp_packed2&BEAM_LOOSE_MASK), xb((tmp_packed2>>BEAM_LOOSE_SHIFT)));
    NextPF(2, next);
    }

OpCase(move_call_last_xrfP):
    MoveCallLast(xb(Arg(0)), r(0), Arg(1), Arg(2));

OpCase(move_call_last_yrfP):
    MoveCallLast(yb(Arg(0)), r(0), Arg(1), Arg(2));

OpCase(move_call_only_xrf):
    MoveCallOnly(xb(Arg(0)), r(0), Arg(1));

OpCase(move_call_xrf):
    MoveCall(xb(Arg(0)), r(0), Arg(1), 2);

OpCase(move_call_yrf):
    MoveCall(yb(Arg(0)), r(0), Arg(1), 2);

OpCase(move_cr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Move(Arg(0), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_cx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    Move(Arg(0), xb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(move_cy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    Move(Arg(0), yb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(move_deallocate_return_crP):
    MoveDeallocateReturn(Arg(0), r(0), Arg(1));

OpCase(move_deallocate_return_nrP):
    MoveDeallocateReturn(NIL, r(0), Arg(0));

OpCase(move_deallocate_return_xrP):
    MoveDeallocateReturn(xb(Arg(0)), r(0), Arg(1));

OpCase(move_deallocate_return_yrP):
    MoveDeallocateReturn(yb(Arg(0)), r(0), Arg(1));

OpCase(move_nr):
    { 
    BeamInstr* next;
    PreFetch(0, next);
    Move(NIL, r(0), StoreSimpleDest);
    NextPF(0, next);
    }

OpCase(move_nx):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Move(NIL, xb(Arg(0)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_return_cr):
    MoveReturn(Arg(0), r(0));

OpCase(move_return_nr):
    MoveReturn(NIL, r(0));

OpCase(move_return_xr):
    MoveReturn(xb(Arg(0)), r(0));

OpCase(move_rx):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Move(r(0), xb(Arg(0)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_ry):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Move(r(0), yb(Arg(0)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_xr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Move(xb(Arg(0)), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_xx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Move(xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_xy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Move(xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_yr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Move(yb(Arg(0)), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_yx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Move(yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(move_yy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    Move(yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(node_r):
    { 
    BeamInstr* next;
    PreFetch(0, next);
    Node(r(0));
    NextPF(0, next);
    }

OpCase(node_x):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Node(xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(put_c):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Put(Arg(0));
    NextPF(1, next);
    }

OpCase(put_list_cnr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutList(Arg(0), NIL, r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_cnx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(Arg(0), NIL, xb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_crr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutList(Arg(0), r(0), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_crx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(Arg(0), r(0), xb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cry):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(Arg(0), r(0), yb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cxr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(Arg(0), xb(Arg(1)), r(0), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutList(Arg(0), xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cxy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutList(Arg(0), xb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cyr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(Arg(0), yb(Arg(1)), r(0), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cyx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutList(Arg(0), yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_cyy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(1);
    PutList(Arg(0), yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_rcr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutList(r(0), Arg(0), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_rcx):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(r(0), Arg(0), xb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_rcy):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(r(0), Arg(0), yb(Arg(1)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_rnx):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutList(r(0), NIL, xb(Arg(0)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_rxr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutList(r(0), xb(Arg(0)), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_rxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(r(0), xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_ryx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(r(0), yb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_xcr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(xb(Arg(0)), Arg(1), r(0), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_xcx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    PutList(xb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_xcy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    PutList(xb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_xnx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(xb(tmp_packed1&BEAM_LOOSE_MASK), NIL, xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_xxr):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(xb(tmp_packed1&BEAM_LOOSE_MASK), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_xxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(xb(tmp_packed1&BEAM_TIGHT_MASK), xb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_xyx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(xb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_ycr):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    PutList(yb(Arg(0)), Arg(1), r(0), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_ycx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_ycy):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(2, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_LOOSE_MASK), Arg(1), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(2, next);
    }

OpCase(put_list_ynx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_LOOSE_MASK), NIL, xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_yrr):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    PutList(yb(Arg(0)), r(0), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_yrx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_LOOSE_MASK), r(0), xb((tmp_packed1>>BEAM_LOOSE_SHIFT)), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_yxx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_TIGHT_MASK), xb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_yyr):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_LOOSE_MASK), yb((tmp_packed1>>BEAM_LOOSE_SHIFT)), r(0), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_list_yyx):
    { BeamInstr tmp_packed1;
    BeamInstr* next;
    PreFetch(1, next);
    tmp_packed1 = Arg(0);
    PutList(yb(tmp_packed1&BEAM_TIGHT_MASK), yb((tmp_packed1>>BEAM_TIGHT_SHIFT)&BEAM_TIGHT_MASK), xb((tmp_packed1>>(2*BEAM_TIGHT_SHIFT))&BEAM_TIGHT_MASK), StoreSimpleDest);
    NextPF(1, next);
    }

OpCase(put_n):
    { 
    BeamInstr* next;
    PreFetch(0, next);
    Put(NIL);
    NextPF(0, next);
    }

OpCase(put_r):
    { 
    BeamInstr* next;
    PreFetch(0, next);
    Put(r(0));
    NextPF(0, next);
    }

OpCase(put_x):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Put(xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(put_y):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Put(yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(self_r):
    { 
    BeamInstr* next;
    PreFetch(0, next);
    Self(r(0));
    NextPF(0, next);
    }

OpCase(self_x):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Self(xb(Arg(0)));
    NextPF(1, next);
    }

OpCase(self_y):
    { 
    BeamInstr* next;
    PreFetch(1, next);
    Self(yb(Arg(0)));
    NextPF(1, next);
    }

OpCase(test_arity_frA):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    IsArity(r(0), Arg(1), ClauseFail());
    NextPF(2, next);
    }

OpCase(test_arity_fxA):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsArity(xb(Arg(1)), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(test_arity_fyA):
    { 
    BeamInstr* next;
    PreFetch(3, next);
    IsArity(yb(Arg(1)), Arg(2), ClauseFail());
    NextPF(3, next);
    }

OpCase(test_heap_II):
    { 
    BeamInstr* next;
    PreFetch(2, next);
    TestHeap(Arg(0), Arg(1));
    NextPF(2, next);
    }