------------------------ OptoAssembly for Compile_id = 696 -----------------------
#  
#  narrowoop: compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point *[int:>=0] (java/lang/Cloneable,java/io/Serializable) * ( compiler/c2/irTests/scalarReplacement/AllocationMergesTests:NotNull *, int, int, int )
#
000     N682: #	out( B1 ) <- BLOCK HEAD IS JUNK  Freq: 1
000     # MachUEPNode
	ldrw rscratch1, j_rarg0 + oopDesc::klass_offset_in_bytes()]	# compressed klass
	cmp r0, rscratch1	 # Inline cache check
	bne, SharedRuntime::_ic_miss_stub

        nop 	# 2 bytes pad for loops and calls

020     B1: #	out( B48 B2 ) <- BLOCK HEAD IS JUNK  Freq: 1
020     # stack bang size=64
	sub  sp, sp, #64
	stp  rfp, lr, [sp, #48]
	ldr  rscratch1, [guard]
	dmb ishld
	ldr  rscratch2, [rthread, #thread_disarmed_guard_value_offset]
	cmp  rscratch1, rscratch2
	b.eq skip
	blr #nmethod_entry_barrier_stub
	b skip
	guard: int
	
	skip:
	
060     addw  R11, R3, R4
064     spill R2 -> [sp, #0]	# spill size = 32
068 +   spill R4 -> [sp, #8]	# spill size = 32
06c +   spill R3 -> [sp, #4]	# spill size = 32
06c +   spill R11 -> [sp, #12]	# spill size = 32
070 +   mov  R1, precise [compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point: 0x000000013f1a5bf8 * (java/lang/Cloneable,java/io/Serializable): :Constant:exact *	# ptr
	
07c     mov R2, #2	# int
080     call,static 0x0000000117492940 	// ==>  wrapper for: _new_array_Java
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests$PicturePositions::<init> @ bci:11 (line 868) L[0]=_ L[1]=_ L[2]=r31_sp + #8 L[3]=r31_sp + #12 STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #4, [positions :1]=#null }
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests::testNestedObjectsArray @ bci:9 (line 505) L[0]=_ L[1]=r31_sp + #0 L[2]=r31_sp + #4 L[3]=r31_sp + #8 L[4]=_ STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #4, [positions :1]=#null }
        # OopMap {off=132/0x84}

090     B2: #	out( B49 B3 ) <- in( B1 )  Freq: 0.99998
        # Block is sole successor of call
090     
090 +   # checkcastPP of R0
090     mov  R1, precise compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point: 0x000000013f1a5bf8:Constant:exact *	# ptr
	
09c     add R29, R0, #16	# ptr
0a0     spill R0 -> [sp, #16]	# spill size = 64
0a4     call,static 0x0000000117492640 	// ==>  wrapper for: _new_instance_Java
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests$PicturePositions::<init> @ bci:16 (line 868) L[0]=_ L[1]=_ L[2]=r31_sp + #8 L[3]=r31_sp + #12 STK[0]=#ScObj0 STK[1]=r31_sp + #16 STK[2]=r31_sp + #16 STK[3]=#0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #4, [positions :1]=#null }
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests::testNestedObjectsArray @ bci:9 (line 505) L[0]=_ L[1]=r31_sp + #0 L[2]=r31_sp + #4 L[3]=r31_sp + #8 L[4]=_ STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #4, [positions :1]=#null }
        # OopMap {rfp=Derived_oop_[16] [16]=Oop off=168/0xa8}

0b4     B3: #	out( B5 B4 ) <- in( B2 )  Freq: 0.99996
        # Block is sole successor of call
0b4 +   spill [sp, #12] -> R20	# spill size = 32
0b8 +   strw  R20, [R0, #16]	# int
0bc     spill [sp, #8] -> R19	# spill size = 32
0c0 +   strw  R19, [R0, #12]	# int
0c4     
0c4 +   # checkcastPP of R0
0c4     mov R10, R29	# ptr -> long
0c8     mov R11, R0	# ptr -> long
0cc +   encode_heap_oop_not_null R12, R0
0e0     eor  R11, R11, R10	# int
0e4 +   strw  R12, [R29]	# compressed ptr
0e8     lsr R11, R11, (#20 & 0x3f)
0ec     spill [sp, #16] -> R21	# spill size = 64
0f0 +   add R29, R21, #20	# ptr
0f4     cbeq   R11, B5  P=0.001000 C=-1.000000

0f8     B4: #	out( B24 B5 ) <- in( B3 )  Freq: 0.99896
0f8 +   lsr R10, R10, (#9 & 0x3f)
0fc +   adr  R11, 0x0000000100b04000	# Byte Map Base
108     add R0, R11, R10	# ptr
10c +   ldrsbw  R11, [R0]	# byte
110 +   cmpw  R11, #2
114     bne  B24  P=0.001000 C=-1.000000

118     B5: #	out( B50 B6 ) <- in( B26 B27 B24 B4 B3 )  Freq: 0.99996
118 +   mov  R1, precise compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point: 0x000000013f1a5bf8:Constant:exact *	# ptr
	
124     call,static 0x0000000117492640 	// ==>  wrapper for: _new_instance_Java
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests$PicturePositions::<init> @ bci:28 (line 868) L[0]=_ L[1]=_ L[2]=r31_sp + #8 L[3]=r31_sp + #12 STK[0]=#ScObj0 STK[1]=r31_sp + #16 STK[2]=r31_sp + #16 STK[3]=#1
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #4, [positions :1]=#null }
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests::testNestedObjectsArray @ bci:9 (line 505) L[0]=_ L[1]=r31_sp + #0 L[2]=r31_sp + #4 L[3]=r31_sp + #8 L[4]=_ STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #4, [positions :1]=#null }
        # OopMap {rfp=Derived_oop_[16] [16]=Oop off=296/0x128}

134     B6: #	out( B21 B7 ) <- in( B5 )  Freq: 0.99994
        # Block is sole successor of call
134 +   spill [sp, #8] -> R19	# spill size = 32
138 +   spill R0 -> R21	# spill size = 64
13c +   strw  R19, [R21, #16]	# int
140     spill [sp, #12] -> R20	# spill size = 32
144 +   strw  R20, [R21, #12]	# int
148     spill R21 -> R10	# spill size = 64
14c     
14c +    -- 	// R28=Thread::current(), empty
14c     ldrsbw  R11, [R28, #64]	# byte
150     # checkcastPP of R21
150     cbwne   R11, B21  P=0.001000 C=-1.000000

154     B7: #	out( B9 B8 ) <- in( B43 B23 B21 B6 )  Freq: 0.99994
154 +   mov R11, R29	# ptr -> long
158     mov R10, R21	# ptr -> long
15c +   eor  R10, R10, R11	# int
160 +   encode_heap_oop_not_null R12, R21
174 +   lsr R10, R10, (#20 & 0x3f)
178 +   strw  R12, [R29]	# compressed ptr
17c     cbeq   R10, B9  P=0.001000 C=-1.000000

180     B8: #	out( B28 B9 ) <- in( B7 )  Freq: 0.99894
180 +   lsr R10, R11, (#9 & 0x3f)
184 +   adr  R11, 0x0000000100b04000	# Byte Map Base
190     add R0, R11, R10	# ptr
194 +   ldrsbw  R11, [R0]	# byte
198 +   cmpw  R11, #2
19c     bne  B28  P=0.001000 C=-1.000000

1a0     B9: #	out( B19 B10 ) <- in( B30 B31 B28 B8 B7 )  Freq: 0.99994
1a0 +   spill [sp, #0] -> R11	# spill size = 32
1a4 +   cbweq   R11, B19  P=0.501000 C=2000.000000

1a8     B10: #	out( B47 B11 ) <- in( B9 )  Freq: 0.49897
1a8 +   spill [sp, #4] -> R10	# spill size = 32
1ac +   addw R10, R10, #1
1b0     spill R10 -> [sp, #0]	# spill size = 32
1b4 +   addw R11, R20, #1
1b8     addw R10, R19, #1
1bc     spill R11 -> [sp, #4]	# spill size = 32
1c0 +   spill R10 -> [sp, #8]	# spill size = 32
1c0 +   mov  R1, precise [compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point: 0x000000013f1a5bf8 * (java/lang/Cloneable,java/io/Serializable): :Constant:exact *	# ptr
	
1cc     mov R2, #2	# int
1d0     call,static 0x0000000117492940 	// ==>  wrapper for: _new_array_Java
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests$PicturePositions::<init> @ bci:11 (line 868) L[0]=_ L[1]=_ L[2]=r31_sp + #8 L[3]=r31_sp + #4 STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #0, [positions :1]=#null }
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests::testNestedObjectsArray @ bci:33 (line 508) L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #0, [positions :1]=#null }
        # OopMap {off=468/0x1d4}

1e0     B11: #	out( B46 B12 ) <- in( B10 )  Freq: 0.49896
        # Block is sole successor of call
1e0     
1e0 +   # checkcastPP of R0
1e0     mov  R1, precise compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point: 0x000000013f1a5bf8:Constant:exact *	# ptr
	
1ec     add R29, R0, #16	# ptr
1f0     spill R0 -> [sp, #16]	# spill size = 64
1f4     call,static 0x0000000117492640 	// ==>  wrapper for: _new_instance_Java
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests$PicturePositions::<init> @ bci:16 (line 868) L[0]=_ L[1]=_ L[2]=r31_sp + #8 L[3]=r31_sp + #4 STK[0]=#ScObj0 STK[1]=r31_sp + #16 STK[2]=r31_sp + #16 STK[3]=#0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #0, [positions :1]=#null }
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests::testNestedObjectsArray @ bci:33 (line 508) L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #0, [positions :1]=#null }
        # OopMap {rfp=Derived_oop_[16] [16]=Oop off=504/0x1f8}

204     B12: #	out( B14 B13 ) <- in( B11 )  Freq: 0.49895
        # Block is sole successor of call
204 +   spill [sp, #4] -> R20	# spill size = 32
208 +   strw  R20, [R0, #16]	# int
20c     spill [sp, #8] -> R19	# spill size = 32
210 +   strw  R19, [R0, #12]	# int
214     
214 +   # checkcastPP of R0
214     mov R10, R29	# ptr -> long
218     mov R11, R0	# ptr -> long
21c +   encode_heap_oop_not_null R12, R0
230     eor  R11, R11, R10	# int
234 +   strw  R12, [R29]	# compressed ptr
238     lsr R11, R11, (#20 & 0x3f)
23c     spill [sp, #16] -> R21	# spill size = 64
240 +   add R29, R21, #20	# ptr
244     cbeq   R11, B14  P=0.001000 C=-1.000000

248     B13: #	out( B35 B14 ) <- in( B12 )  Freq: 0.498451
248 +   lsr R10, R10, (#9 & 0x3f)
24c +   adr  R11, 0x0000000100b04000	# Byte Map Base
258     add R0, R11, R10	# ptr
25c +   ldrsbw  R11, [R0]	# byte
260 +   cmpw  R11, #2
264     bne  B35  P=0.001000 C=-1.000000

268     B14: #	out( B45 B15 ) <- in( B37 B38 B35 B13 B12 )  Freq: 0.49895
268 +   mov  R1, precise compiler/c2/irTests/scalarReplacement/AllocationMergesTests$Point: 0x000000013f1a5bf8:Constant:exact *	# ptr
	
274     call,static 0x0000000117492640 	// ==>  wrapper for: _new_instance_Java
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests$PicturePositions::<init> @ bci:28 (line 868) L[0]=_ L[1]=_ L[2]=r31_sp + #8 L[3]=r31_sp + #4 STK[0]=#ScObj0 STK[1]=r31_sp + #16 STK[2]=r31_sp + #16 STK[3]=#1
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #0, [positions :1]=#null }
        # compiler.c2.irTests.scalarReplacement.AllocationMergesTests::testNestedObjectsArray @ bci:33 (line 508) L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ STK[0]=#ScObj0
        # ScObj0 compiler/c2/irTests/scalarReplacement/AllocationMergesTests$PicturePositions={ [id :0]=r31_sp + #0, [positions :1]=#null }
        # OopMap {rfp=Derived_oop_[16] [16]=Oop off=632/0x278}

284     B15: #	out( B32 B16 ) <- in( B14 )  Freq: 0.49894
        # Block is sole successor of call
284 +   spill [sp, #8] -> R10	# spill size = 32
288 +   spill R0 -> R19	# spill size = 64
28c +   strw  R10, [R19, #16]	# int
290     spill [sp, #4] -> R11	# spill size = 32
294 +   strw  R11, [R19, #12]	# int
298     spill R19 -> R10	# spill size = 64
29c     
29c +    -- 	// R28=Thread::current(), empty
29c     ldrsbw  R10, [R28, #64]	# byte
2a0     # checkcastPP of R19
2a0     cbwne   R10, B32  P=0.001000 C=-1.000000

2a4     B16: #	out( B18 B17 ) <- in( B44 B34 B32 B15 )  Freq: 0.49894
2a4 +   mov R10, R29	# ptr -> long
2a8     mov R11, R19	# ptr -> long
2ac +   eor  R11, R11, R10	# int
2b0 +   encode_heap_oop_not_null R12, R19
2c4 +   lsr R11, R11, (#20 & 0x3f)
2c8 +   strw  R12, [R29]	# compressed ptr
2cc     cbeq   R11, B18  P=0.001000 C=-1.000000

2d0     B17: #	out( B39 B18 ) <- in( B16 )  Freq: 0.498441
2d0 +   lsr R10, R10, (#9 & 0x3f)
2d4 +   adr  R11, 0x0000000100b04000	# Byte Map Base
2e0     add R0, R11, R10	# ptr
2e4 +   ldrsbw  R11, [R0]	# byte
2e8 +   cmpw  R11, #2
2ec     bne  B39  P=0.001000 C=-1.000000

2f0     B18: #	out( B20 ) <- in( B41 B42 B39 B17 B16 )  Freq: 0.49894
2f0 +   spill [sp, #16] -> R0	# spill size = 64
2f4 +   b  B20

2f8     B19: #	out( B20 ) <- in( B9 )  Freq: 0.50097
2f8 +   spill [sp, #16] -> R0	# spill size = 64

2fc     B20: #	out( N682 ) <- in( B18 B19 )  Freq: 0.99991
2fc     # pop frame 64
	ldp  lr, rfp, [sp,#48]
	add  sp, sp, #64
	# test polling word
	ldr  rscratch1, [rthread],#960
	cmp  sp, rscratch1
	bhi #slow_path
310 +   ret	// return register

314     B21: #	out( B7 B22 ) <- in( B6 )  Freq: 0.000999927
314 +   ldrw  R11, [R29]	# compressed ptr
318 +   decode_heap_oop R0, R11
31c     cbeq   R0, B7  P=0.500000 C=-1.000000

320     B22: #	out( B43 B23 ) <- in( B21 )  Freq: 0.000499964
320 +    -- 	// R28=Thread::current(), empty
320     ldr  R10, [R28, #40]	# int
324     cbeq   R10, B43  P=0.001000 C=-1.000000

328     B23: #	out( B7 ) <- in( B22 )  Freq: 0.000499464
328 +    -- 	// R28=Thread::current(), empty
328     ldr  R11, [R28, #56]	# ptr
32c +   add R12, R10, #-8
330 +   add R10, R11, R10	# ptr
334     str  R0, [R10, #-8]	# ptr
338 +    -- 	// R28=Thread::current(), empty
338     str  R12, [R28, #40]	# int
33c     b  B7

340     B24: #	out( B5 B25 ) <- in( B4 )  Freq: 0.00099896
340 +    -- 	// R28=Thread::current(), empty
340     ldr  R10, [R28, #88]	# ptr
344 +    -- 	// R28=Thread::current(), empty
344     ldr  R11, [R28, #72]	# int
348 +   membar_volatile
	dmb ish
34c +   ldrsbw  R13, [R0]	# byte
350     cbweq   R13, B5  P=0.500000 C=-1.000000

354     B25: #	out( B27 B26 ) <- in( B24 )  Freq: 0.00049948
354 +   storestore (elided)
	strb zr, [R0]	# byte
358     cbne   R11, B27  P=0.500000 C=-1.000000

35c     B26: #	out( B5 ) <- in( B25 )  Freq: 0.00024974
35c +    -- 	// R28=Thread::current(), empty
35c     spill R28 -> R1	# spill size = 64
360 +   CALL, runtime leaf 0x00000001064eef68 write_ref_field_post_entry
        No JVM State Info
        # 
388 +   b  B5

38c     B27: #	out( B5 ) <- in( B25 )  Freq: 0.00024974
38c +   add R12, R11, #-8
390 +   add R10, R10, R11	# ptr
394     str  R0, [R10, #-8]	# ptr
398 +    -- 	// R28=Thread::current(), empty
398     str  R12, [R28, #72]	# int
39c     b  B5

3a0     B28: #	out( B9 B29 ) <- in( B8 )  Freq: 0.00099894
3a0 +    -- 	// R28=Thread::current(), empty
3a0     ldr  R10, [R28, #88]	# ptr
3a4 +    -- 	// R28=Thread::current(), empty
3a4     ldr  R11, [R28, #72]	# int
3a8 +   membar_volatile
	dmb ish
3ac +   ldrsbw  R13, [R0]	# byte
3b0     cbweq   R13, B9  P=0.500000 C=-1.000000

3b4     B29: #	out( B31 B30 ) <- in( B28 )  Freq: 0.00049947
3b4 +   storestore (elided)
	strb zr, [R0]	# byte
3b8     cbne   R11, B31  P=0.500000 C=-1.000000

3bc     B30: #	out( B9 ) <- in( B29 )  Freq: 0.000249735
3bc +    -- 	// R28=Thread::current(), empty
3bc     spill R28 -> R1	# spill size = 64
3c0 +   CALL, runtime leaf 0x00000001064eef68 write_ref_field_post_entry
        No JVM State Info
        # 
3e8 +   b  B9

3ec     B31: #	out( B9 ) <- in( B29 )  Freq: 0.000249735
3ec +   add R12, R11, #-8
3f0 +   add R10, R10, R11	# ptr
3f4     str  R0, [R10, #-8]	# ptr
3f8 +    -- 	// R28=Thread::current(), empty
3f8     str  R12, [R28, #72]	# int
3fc     b  B9

400     B32: #	out( B16 B33 ) <- in( B15 )  Freq: 0.000498934
400 +   ldrw  R11, [R29]	# compressed ptr
404 +   decode_heap_oop R0, R11
408     cbeq   R0, B16  P=0.500000 C=-1.000000

40c     B33: #	out( B44 B34 ) <- in( B32 )  Freq: 0.000249467
40c +    -- 	// R28=Thread::current(), empty
40c     ldr  R10, [R28, #40]	# int
410     cbeq   R10, B44  P=0.001000 C=-1.000000

414     B34: #	out( B16 ) <- in( B33 )  Freq: 0.000249217
414 +    -- 	// R28=Thread::current(), empty
414     ldr  R11, [R28, #56]	# ptr
418 +   add R12, R10, #-8
41c +   add R10, R11, R10	# ptr
420     str  R0, [R10, #-8]	# ptr
424 +    -- 	// R28=Thread::current(), empty
424     str  R12, [R28, #40]	# int
428     b  B16

42c     B35: #	out( B14 B36 ) <- in( B13 )  Freq: 0.000498451
42c +    -- 	// R28=Thread::current(), empty
42c     ldr  R10, [R28, #88]	# ptr
430 +    -- 	// R28=Thread::current(), empty
430     ldr  R11, [R28, #72]	# int
434 +   membar_volatile
	dmb ish
438 +   ldrsbw  R13, [R0]	# byte
43c     cbweq   R13, B14  P=0.500000 C=-1.000000

440     B36: #	out( B38 B37 ) <- in( B35 )  Freq: 0.000249226
440 +   storestore (elided)
	strb zr, [R0]	# byte
444     cbne   R11, B38  P=0.500000 C=-1.000000

448     B37: #	out( B14 ) <- in( B36 )  Freq: 0.000124613
448 +    -- 	// R28=Thread::current(), empty
448     spill R28 -> R1	# spill size = 64
44c +   CALL, runtime leaf 0x00000001064eef68 write_ref_field_post_entry
        No JVM State Info
        # 
474 +   b  B14

478     B38: #	out( B14 ) <- in( B36 )  Freq: 0.000124613
478 +   add R12, R11, #-8
47c +   add R10, R10, R11	# ptr
480     str  R0, [R10, #-8]	# ptr
484 +    -- 	// R28=Thread::current(), empty
484     str  R12, [R28, #72]	# int
488     b  B14

48c     B39: #	out( B18 B40 ) <- in( B17 )  Freq: 0.000498441
48c +    -- 	// R28=Thread::current(), empty
48c     ldr  R10, [R28, #88]	# ptr
490 +    -- 	// R28=Thread::current(), empty
490     ldr  R11, [R28, #72]	# int
494 +   membar_volatile
	dmb ish
498 +   ldrsbw  R13, [R0]	# byte
49c     cbweq   R13, B18  P=0.500000 C=-1.000000

4a0     B40: #	out( B42 B41 ) <- in( B39 )  Freq: 0.000249221
4a0 +   storestore (elided)
	strb zr, [R0]	# byte
4a4     cbne   R11, B42  P=0.500000 C=-1.000000

4a8     B41: #	out( B18 ) <- in( B40 )  Freq: 0.00012461
4a8 +    -- 	// R28=Thread::current(), empty
4a8     spill R28 -> R1	# spill size = 64
4ac +   CALL, runtime leaf 0x00000001064eef68 write_ref_field_post_entry
        No JVM State Info
        # 
4d4 +   b  B18

4d8     B42: #	out( B18 ) <- in( B40 )  Freq: 0.00012461
4d8 +   add R12, R11, #-8
4dc +   add R10, R10, R11	# ptr
4e0     str  R0, [R10, #-8]	# ptr
4e4 +    -- 	// R28=Thread::current(), empty
4e4     str  R12, [R28, #72]	# int
4e8     b  B18

4ec     B43: #	out( B7 ) <- in( B22 )  Freq: 4.99957e-07
4ec +    -- 	// R28=Thread::current(), empty
4ec     spill R28 -> R1	# spill size = 64
4f0 +   CALL, runtime leaf 0x00000001064eebec write_ref_field_pre_entry
        No JVM State Info
        # 
518 +   b  B7

51c     B44: #	out( B16 ) <- in( B33 )  Freq: 2.49464e-07
51c +    -- 	// R28=Thread::current(), empty
51c     spill R28 -> R1	# spill size = 64
520 +   CALL, runtime leaf 0x00000001064eebec write_ref_field_pre_entry
        No JVM State Info
        # 
548 +   b  B16

54c     B45: #	out( B51 ) <- in( B14 )  Freq: 4.9895e-06
54c      -- 	// exception oop; no code emitted
54c +   spill R0 -> R1	# spill size = 64
550 +   b  B51

554     B46: #	out( B51 ) <- in( B11 )  Freq: 4.9896e-06
554      -- 	// exception oop; no code emitted
554 +   spill R0 -> R1	# spill size = 64
558 +   b  B51

55c     B47: #	out( B51 ) <- in( B10 )  Freq: 4.9897e-06
55c      -- 	// exception oop; no code emitted
55c +   spill R0 -> R1	# spill size = 64
560 +   b  B51

564     B48: #	out( B51 ) <- in( B1 )  Freq: 1e-05
564      -- 	// exception oop; no code emitted
564 +   spill R0 -> R1	# spill size = 64
568 +   b  B51

56c     B49: #	out( B51 ) <- in( B2 )  Freq: 9.9998e-06
56c      -- 	// exception oop; no code emitted
56c +   spill R0 -> R1	# spill size = 64
570 +   b  B51

574     B50: #	out( B51 ) <- in( B5 )  Freq: 9.9996e-06
574      -- 	// exception oop; no code emitted
574 +   spill R0 -> R1	# spill size = 64

578     B51: #	out( N682 ) <- in( B45 B48 B49 B50 B46 B47 )  Freq: 4.49682e-05
578     # pop frame 64
	ldp  lr, rfp, [sp,#48]
	add  sp, sp, #64
	
580 +   b rethrow_stub