data mut $"regions.session.allocate::regions.session.allocate::main$nominal$DATA" align 1 {
    w8 0 * 256;
}

data $"regions.session.allocate::main$literal$0" align 1 {
    str "value";
}

fn w64 $"regions.session.allocate::create"(w64 %0, w64 %1, w32 %2) {
  @entry0
    load w64 %3 %1 0;
    load w64 %4 %1 8;
    load w64 %5 %4 0;
    reserve %6 16 8;
    call w64 %7 %5(%6, %3, 4, 4);
    load w64 %8 %7 0;
    reserve %9 8 8;
    br.ne w32 %8 0 @err2 @ok1;
  @ok1
    load w64 %10 %7 8;
    store w32 %2 %10 0;
    load w64 %11 %7 8;
    store w64 %11 %9 0;
    jmp @merge3;
  @err2
    reserve %12 16 8;
    store w64 %8 %12 0;
    add w64 %13 %7 8;
    add w64 %14 %12 8;
    blit %14 %13 1;
    blit %0 %12 16;
    ret %0;
  @merge3
    load w64 %15 %9 0;
    reserve %16 16 8;
    store w64 0 %16 0;
    store w64 %15 %16 8;
    blit %0 %16 16;
    ret %0;
}

fn w64 $"regions.session.allocate::initializer"(w64 %0, w64 %1) {
  @entry0
    store w32 42 %1 0;
    reserve %2 12 8;
    store w64 1 %2 0;
    store w8 0 %2 8;
    blit %0 %2 12;
    ret %0;
}

fn w64 $"regions.session.allocate::failedInitializer"(w64 %0, w64 %1, w64 %2) {
  @entry0
    load w64 %3 %1 0;
    load w64 %4 %1 8;
    load w64 %5 %4 0;
    reserve %6 12 8;
    call w64 %7 $"regions.session.allocate::initializer"(%6, %2);
    load w64 %8 %7 0;
    reserve %9 4 4;
    br.ne w32 %8 0 @err2 @ok1;
  @ok1
    load w32 %10 %7 8;
    store w32 %10 %9 0;
    jmp @merge3;
  @err2
    reserve %11 16 8;
    store w64 %8 %11 0;
    add w64 %12 %7 8;
    add w64 %13 %11 8;
    blit %13 %12 1;
    blit %0 %11 16;
    ret %0;
  @merge3
    load w32 %14 %9 0;
    reserve %15 16 8;
    call w64 %16 %5(%15, %3, 4, 4);
    load w64 %17 %16 0;
    reserve %18 8 8;
    br.ne w32 %17 0 @err5 @ok4;
  @ok4
    load w64 %19 %16 8;
    store w32 %14 %19 0;
    load w64 %20 %16 8;
    store w64 %20 %18 0;
    jmp @merge6;
  @err5
    reserve %21 16 8;
    store w64 %17 %21 0;
    add w64 %22 %16 8;
    add w64 %23 %21 8;
    blit %23 %22 1;
    blit %0 %21 16;
    ret %0;
  @merge6
    load w64 %24 %18 0;
    reserve %25 16 8;
    store w64 0 %25 0;
    store w64 %24 %25 8;
    blit %0 %25 16;
    ret %0;
}

fn w64 $"regions.session.allocate::failures"(w64 %0) {
  @entry0
    call w32 %1 $"std::lang::alloc::used"(%0);
    reserve %2 4 4;
    store w32 0 %2 0;
    reserve %3 16 8;
    store w64 %0 %3 0;
    store w64 $"std::lang::alloc::vtable::Arena::Alloc" %3 8;
    reserve %4 16 8;
    call w64 %5 $"regions.session.allocate::failedInitializer"(%4, %3, %2);
    load w64 %6 %5 0;
    reserve %7 8 8;
    br.ne w32 %6 0 @err2 @ok1;
  @ok1
    load w64 %8 %5 8;
    store w64 %8 %7 0;
    jmp @merge3;
  @err2
    switch %6 (1 @catch4) @unreachable5;
  @merge3
    load w64 %11 %7 0;
    load w64 %13 %3 0;
    load w64 %14 %3 8;
    load w64 %15 %14 8;
    reserve %16 24 8;
    call w64 %17 %15(%16, %13, 8, 8, 4294967295);
    load w64 %18 %17 0;
    reserve %19 16 8;
    br.ne w32 %18 0 @err9 @ok8;
  @catch4
    load w8 %9 %5 8;
    load w32 %10 %2 0;
    br.eq w32 %10 42 @assert.ok7 @assert.fail6;
  @unreachable5
    unreachable;
  @assert.fail6
    unreachable;
  @assert.ok7
    jmp @merge3;
  @ok8
    load w64 %20 %17 8;
    jmp @fill10(0);
  @err9
    reserve %26 16 8;
    store w64 0 %26 0;
    store w32 0 %26 8;
    store w32 0 %26 12;
    blit %19 %26 16;
    jmp @merge13;
  @fill10(w32 %21)
    br.ult w32 %21 4294967295 @fill11 @fill12;
  @fill11
    mul w64 %22 %21 8;
    add w64 %23 %20 %22;
    store w64 1 %23 0;
    add w32 %24 %21 1;
    jmp @fill10(%24);
  @fill12
    add w64 %25 %17 8;
    blit %19 %25 16;
    jmp @merge13;
  @merge13
    reserve %27 16 8;
    blit %27 %19 16;
    load w64 %28 %27 0;
    br.ne w32 %28 0 @then14 @else15;
  @then14
    unreachable;
  @else15
    jmp @merge16;
  @merge16
    load w64 %31 %3 0;
    load w64 %32 %3 8;
    load w64 %33 %32 8;
    zext w32 %34 1;
    reserve %35 24 8;
    call w64 %36 %33(%35, %31, 4, 4, 256);
    load w64 %37 %36 0;
    reserve %38 16 8;
    br.ne w32 %37 0 @err18 @ok17;
  @ok17
    load w64 %39 %36 8;
    jmp @fill19(0);
  @err18
    switch %37 (1 @catch23) @unreachable24;
  @fill19(w32 %40)
    br.ult w32 %40 256 @fill20 @fill21;
  @fill20
    mul w64 %41 %40 4;
    add w64 %42 %39 %41;
    store w32 %34 %42 0;
    add w32 %43 %40 1;
    jmp @fill19(%43);
  @fill21
    add w64 %44 %36 8;
    blit %38 %44 16;
    jmp @merge22;
  @merge22
    call w32 %55 $"std::lang::alloc::used"(%0);
    br.eq w32 %55 %1 @assert.ok28 @assert.fail27;
  @catch23
    load w8 %45 %36 8;
    load w32 %49 %2 0;
    br.eq w32 %49 42 @assert.ok26 @assert.fail25;
  @unreachable24
    unreachable;
  @assert.fail25
    unreachable;
  @assert.ok26
    jmp @merge22;
  @assert.fail27
    unreachable;
  @assert.ok28
    load w32 %63 %2 0;
    br.eq w32 %63 42 @assert.ok30 @assert.fail29;
  @assert.fail29
    unreachable;
  @assert.ok30
    ret;
}

fn w32 $"regions.session.allocate::main"() {
  @entry0
    copy %0 $"regions.session.allocate::regions.session.allocate::main$nominal$DATA";
    add w64 %1 %0 1;
    sub w32 %2 256 1;
    reserve %3 16 8;
    store w64 %1 %3 0;
    store w32 %2 %3 8;
    store w32 %2 %3 12;
    reserve %4 24 8;
    call w64 %5 $"std::lang::alloc::new"(%4, %3);
    call w64 $"regions.session.allocate::failures"(%5);
    reserve %6 16 8;
    store w64 %5 %6 0;
    store w64 $"std::lang::alloc::vtable::Arena::Alloc" %6 8;
    load w64 %7 %6 0;
    load w64 %8 %6 8;
    load w64 %9 %8 0;
    reserve %10 4 4;
    store w32 7 %10 0;
    reserve %11 16 8;
    call w64 %12 %9(%11, %7, 4, 4);
    load w64 %13 %12 0;
    reserve %14 8 8;
    br.ne w32 %13 0 @err2 @ok1;
  @ok1
    load w64 %15 %12 8;
    blit %15 %10 4;
    load w64 %16 %12 8;
    store w64 %16 %14 0;
    jmp @merge3;
  @err2
    unreachable;
  @merge3
    load w64 %17 %14 0;
    load w32 %18 %17 0;
    br.eq w32 %18 7 @assert.ok5 @assert.fail4;
  @assert.fail4
    unreachable;
  @assert.ok5
    load w64 %19 %6 0;
    load w64 %20 %6 8;
    load w64 %21 %20 0;
    copy %22 $"regions.session.allocate::main$literal$0";
    reserve %23 16 8;
    store w64 %22 %23 0;
    store w32 5 %23 8;
    store w32 5 %23 12;
    reserve %24 16 8;
    call w64 %25 %21(%24, %19, 16, 8);
    load w64 %26 %25 0;
    reserve %27 8 8;
    br.ne w32 %26 0 @err7 @ok6;
  @ok6
    load w64 %28 %25 8;
    blit %28 %23 16;
    load w64 %29 %25 8;
    store w64 %29 %27 0;
    jmp @merge8;
  @err7
    unreachable;
  @merge8
    load w64 %30 %27 0;
    load w32 %31 %30 8;
    br.eq w32 %31 5 @assert.ok10 @assert.fail9;
  @assert.fail9
    unreachable;
  @assert.ok10
    reserve %32 16 8;
    call w64 %33 $"regions.session.allocate::create"(%32, %6, 20);
    load w64 %34 %33 0;
    reserve %35 8 8;
    br.ne w32 %34 0 @err12 @ok11;
  @ok11
    load w64 %36 %33 8;
    store w64 %36 %35 0;
    jmp @merge13;
  @err12
    unreachable;
  @merge13
    load w64 %37 %35 0;
    load w64 %38 %6 0;
    load w64 %39 %6 8;
    load w64 %40 %39 0;
    reserve %41 8 4;
    store w32 11 %41 0;
    store w32 11 %41 4;
    reserve %42 16 8;
    call w64 %43 %40(%42, %38, 8, 4);
    load w64 %44 %43 0;
    reserve %45 8 8;
    br.ne w32 %44 0 @err15 @ok14;
  @ok14
    load w64 %46 %43 8;
    blit %46 %41 8;
    load w64 %47 %43 8;
    store w64 %47 %45 0;
    jmp @merge16;
  @err15
    unreachable;
  @merge16
    load w64 %48 %45 0;
    load w64 %49 %6 0;
    load w64 %50 %6 8;
    load w64 %51 %50 8;
    reserve %52 8 4;
    store w32 1 %52 0;
    store w32 2 %52 4;
    reserve %53 24 8;
    call w64 %54 %51(%53, %49, 8, 4, 3);
    load w64 %55 %54 0;
    reserve %56 16 8;
    br.ne w32 %55 0 @err18 @ok17;
  @ok17
    load w64 %57 %54 8;
    jmp @fill19(0);
  @err18
    unreachable;
  @fill19(w32 %58)
    br.ult w32 %58 3 @fill20 @fill21;
  @fill20
    mul w64 %59 %58 8;
    add w64 %60 %57 %59;
    blit %60 %52 8;
    add w32 %61 %58 1;
    jmp @fill19(%61);
  @fill21
    add w64 %62 %54 8;
    blit %56 %62 16;
    jmp @merge22;
  @merge22
    load w64 %64 %6 0;
    load w64 %65 %6 8;
    load w64 %66 %65 8;
    load w64 %67 %56 0;
    load w32 %68 %56 8;
    reserve %69 16 8;
    store w64 %67 %69 0;
    store w32 %68 %69 8;
    store w32 %68 %69 12;
    load w32 %70 %69 8;
    reserve %71 24 8;
    call w64 %72 %66(%71, %64, 8, 4, %70);
    load w64 %73 %72 0;
    reserve %74 16 8;
    br.ne w32 %73 0 @err24 @ok23;
  @ok23
    load w64 %75 %72 8;
    load w64 %76 %69 0;
    mul w32 %77 %70 8;
    jmp @allocate.copy25(0);
  @err24
    unreachable;
  @allocate.copy25(w32 %78)
    br.ult w32 %78 %77 @allocate.copy26 @allocate.copy27;
  @allocate.copy26
    add w64 %79 %76 %78;
    load w8 %80 %79 0;
    add w64 %81 %75 %78;
    store w8 %80 %81 0;
    add w32 %82 %78 1;
    jmp @allocate.copy25(%82);
  @allocate.copy27
    add w64 %83 %72 8;
    blit %74 %83 16;
    jmp @merge28;
  @merge28
    load w32 %85 %56 8;
    br.ult w32 0 %85 @guard#pass29 @guard#trap30;
  @guard#pass29
    load w64 %86 %56 0;
    store w32 9 %86 0;
    load w32 %87 %74 8;
    br.ult w32 0 %87 @guard#pass33 @guard#trap34;
  @guard#trap30
    ebreak;
    unreachable;
  @assert.fail31
    unreachable;
  @assert.ok32
    load w32 %90 %74 8;
    br.ult w32 2 %90 @guard#pass37 @guard#trap38;
  @guard#pass33
    load w64 %88 %74 0;
    load w32 %89 %88 0;
    br.eq w32 %89 1 @assert.ok32 @assert.fail31;
  @guard#trap34
    ebreak;
    unreachable;
  @assert.fail35
    unreachable;
  @assert.ok36
    load w64 %96 %6 0;
    load w64 %97 %6 8;
    load w64 %98 %97 8;
    reserve %99 16 8;
    copy %100 1;
    br.ne w32 %100 0 @cond#then39 @cond#else40;
  @guard#pass37
    load w64 %91 %74 0;
    mul w64 %92 2 8;
    add w64 %93 %91 %92;
    load w32 %94 %93 4;
    br.eq w32 %94 2 @assert.ok36 @assert.fail35;
  @guard#trap38
    ebreak;
    unreachable;
  @cond#then39
    load w64 %101 %56 0;
    load w32 %102 %56 8;
    reserve %103 16 8;
    store w64 %101 %103 0;
    store w32 %102 %103 8;
    store w32 %102 %103 12;
    blit %99 %103 16;
    jmp @cond#merge41;
  @cond#else40
    load w64 %104 %74 0;
    load w32 %105 %74 8;
    reserve %106 16 8;
    store w64 %104 %106 0;
    store w32 %105 %106 8;
    store w32 %105 %106 12;
    blit %99 %106 16;
    jmp @cond#merge41;
  @cond#merge41
    load w32 %107 %99 8;
    reserve %108 24 8;
    call w64 %109 %98(%108, %96, 8, 4, %107);
    load w64 %110 %109 0;
    reserve %111 16 8;
    br.ne w32 %110 0 @err43 @ok42;
  @ok42
    load w64 %112 %109 8;
    load w64 %113 %99 0;
    mul w32 %114 %107 8;
    jmp @allocate.copy44(0);
  @err43
    unreachable;
  @allocate.copy44(w32 %115)
    br.ult w32 %115 %114 @allocate.copy45 @allocate.copy46;
  @allocate.copy45
    add w64 %116 %113 %115;
    load w8 %117 %116 0;
    add w64 %118 %112 %115;
    store w8 %117 %118 0;
    add w32 %119 %115 1;
    jmp @allocate.copy44(%119);
  @allocate.copy46
    add w64 %120 %109 8;
    blit %111 %120 16;
    jmp @merge47;
  @merge47
    load w32 %121 %111 8;
    br.ult w32 0 %121 @guard#pass50 @guard#trap51;
  @assert.fail48
    unreachable;
  @assert.ok49
    load w32 %126 %56 8;
    br.ult w32 1 %126 @guard#pass52 @guard#trap53;
  @guard#pass50
    load w64 %122 %111 0;
    load w32 %123 %122 0;
    br.eq w32 %123 9 @assert.ok49 @assert.fail48;
  @guard#trap51
    ebreak;
    unreachable;
  @guard#pass52
    load w64 %127 %56 0;
    mul w64 %128 1 8;
    add w64 %129 %127 %128;
    store w32 5 %129 0;
    load w32 %130 %111 8;
    br.ult w32 1 %130 @guard#pass56 @guard#trap57;
  @guard#trap53
    ebreak;
    unreachable;
  @assert.fail54
    unreachable;
  @assert.ok55
    load w64 %137 %6 0;
    load w64 %138 %6 8;
    load w64 %139 %138 0;
    reserve %144 16 8;
    call w64 %145 %139(%144, %137, 8, 8);
    load w64 %146 %145 0;
    reserve %147 8 8;
    br.ne w32 %146 0 @err59 @ok58;
  @guard#pass56
    load w64 %131 %111 0;
    mul w64 %132 1 8;
    add w64 %133 %131 %132;
    load w32 %134 %133 0;
    br.eq w32 %134 1 @assert.ok55 @assert.fail54;
  @guard#trap57
    ebreak;
    unreachable;
  @ok58
    load w64 %148 %145 8;
    store w64 %37 %148 0;
    load w64 %149 %145 8;
    store w64 %149 %147 0;
    jmp @merge60;
  @err59
    unreachable;
  @merge60
    load w64 %150 %147 0;
    load w64 %151 %150 0;
    load w32 %152 %151 0;
    br.eq w32 %152 20 @assert.ok62 @assert.fail61;
  @assert.fail61
    unreachable;
  @assert.ok62
    load w64 %153 %6 0;
    load w64 %154 %6 8;
    load w64 %155 %154 8;
    reserve %156 0 1;
    reserve %157 24 8;
    call w64 %158 %155(%157, %153, 1, 1, 0);
    load w64 %159 %158 0;
    reserve %160 16 8;
    br.ne w32 %159 0 @err64 @ok63;
  @ok63
    load w64 %161 %158 8;
    jmp @fill65(0);
  @err64
    unreachable;
  @fill65(w32 %162)
    br.ult w32 %162 0 @fill66 @fill67;
  @fill66
    mul w64 %163 %162 0;
    add w64 %164 %161 %163;
    blit %164 %156 0;
    add w32 %165 %162 1;
    jmp @fill65(%165);
  @fill67
    add w64 %166 %158 8;
    blit %160 %166 16;
    jmp @merge68;
  @merge68
    load w32 %167 %160 8;
    br.eq w32 %167 0 @assert.ok70 @assert.fail69;
  @assert.fail69
    unreachable;
  @assert.ok70
    load w64 %169 %6 0;
    load w64 %170 %6 8;
    load w64 %171 %170 0;
    reserve %172 0 1;
    reserve %173 16 8;
    call w64 %174 %171(%173, %169, 1, 1);
    load w64 %175 %174 0;
    reserve %176 8 8;
    br.ne w32 %175 0 @err72 @ok71;
  @ok71
    load w64 %177 %174 8;
    blit %177 %172 0;
    load w64 %178 %174 8;
    store w64 %178 %176 0;
    jmp @merge73;
  @err72
    unreachable;
  @merge73
    load w64 %179 %176 0;
    load w64 %180 %6 0;
    load w64 %181 %6 8;
    load w64 %182 %181 8;
    reserve %183 0 1;
    reserve %184 24 8;
    call w64 %185 %182(%184, %180, 1, 1, 2);
    load w64 %186 %185 0;
    reserve %187 16 8;
    br.ne w32 %186 0 @err75 @ok74;
  @ok74
    load w64 %188 %185 8;
    jmp @fill76(0);
  @err75
    unreachable;
  @fill76(w32 %189)
    br.ult w32 %189 2 @fill77 @fill78;
  @fill77
    mul w64 %190 %189 0;
    add w64 %191 %188 %190;
    blit %191 %183 0;
    add w32 %192 %189 1;
    jmp @fill76(%192);
  @fill78
    add w64 %193 %185 8;
    blit %187 %193 16;
    jmp @merge79;
  @merge79
    load w32 %194 %187 8;
    br.eq w32 %194 2 @assert.ok81 @assert.fail80;
  @assert.fail80
    unreachable;
  @assert.ok81
    load w64 %197 %150 0;
    load w32 %198 %197 0;
    br.eq w32 %198 20 @assert.ok83 @assert.fail82;
  @assert.fail82
    unreachable;
  @assert.ok83
    load w32 %205 %48 0;
    load w32 %206 %48 4;
    add w32 %207 %205 %206;
    br.eq w32 %207 22 @assert.ok85 @assert.fail84;
  @assert.fail84
    unreachable;
  @assert.ok85
    load w64 %208 %150 0;
    load w32 %209 %208 0;
    load w32 %210 %48 0;
    add w32 %211 %209 %210;
    load w32 %212 %48 4;
    add w32 %213 %211 %212;
    ret %213;
}