Skip to content

Instantly share code, notes, and snippets.

@joelonsql

joelonsql/gist:7e07ee302ed2d6db82d27473daf19996

Created February 12, 2018 17:02
Show Gist options
  • Save joelonsql/7e07ee302ed2d6db82d27473daf19996 to your computer and use it in GitHub Desktop.
Save joelonsql/7e07ee302ed2d6db82d27473daf19996 to your computer and use it in GitHub Desktop.
Download ZIP
factor.bf -> LLVM IR
Raw
gistfile1.txt
[
Takes an integer from stdin and emits its factors to stdout
Factor an arbitrarily large positive integer
Copyright (C) 1999 by Brian Raiter
under the GNU General Public License
]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-
*
* read in the number
*
<<<<<<<<<+
[-[>>>>>>>>>>][-]<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]<<<<<<<<<<]
>>>>>>>>>>,----------]
>>>>>>>>>>[------------------------------------->>>>>>>>>->]
<[+>[>>>>>>>>>+>]<-<<<<<<<<<<]-
*
* display the number and initialize the loop variable to two
*
[>++++++++++++++++++++++++++++++++++++++++++++++++.
------------------------------------------------<<<<<<<<<<<]
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
--------------------------.[-]
>>>>>>>>>>>>++<<<<+
*
* the main loop
*
[ [-]>>
*
* make copies of the number and the loop variable
*
[>>>>[-]>[-]>[-]>[-]
>[-]>[-]
<<<<<<<[->>>+>+<<<<]>>>>>>>>]
<<<<<<<<<<[>>>>>>[-<<<<+>>>>]<<<<<<<<<<<<<<<<]>>>>>>>>>>
[>[->>>+>>+<<<<<]>>>>>>>>>]
<<<<<<<<<<[>>>>>>[-<<<<<+>>>>>]<<<<<<<<<<<<<<<<]>>>>>>>>>>
*
* divide the number by the loop variable
*
[>>>[-]>>>[-]>[-]>>>] initialize
<<<<<<<<<<[<<<<<<<<<<]
>>>>>>>>>[-]>>>>>>>+<<<<<<<<[+]+
[ ->> double divisor until above dividend
[>>>>>>[->++<]>>>>]<<<<<<<<<<
[>>>>>>>>[-]>[-]
<<<<[->>>++<<<]<<<<<<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>>[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
[->--------->>>>>>>>>+<<<<<<<<<<[->+<]]]]]]]]]]]>>]
<<<<<<<<<<[>>>>>>>>>[-<+<<<+>>>>]<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>
[-<--------->>>>>>>>>>>+<<<<<<<<<<[-<+>]]]]]]]]]]]>>>]
<<<<<<<<<<
[>>>>[->>>+>>+<<<<<]<<<<<<<<<<<<<<]
>>>>>>>>>>[>>>>>>>[-<<<+>>>]>>>]<<<<<<<<<<
[>>>>>>>>[->-<]>
[<<<<<<<<<[<[-]>>>>>>>>>>[-<<<<<<<<<<+>>>>>>>>>>]<<<<<<<<<<<<<<<<<<<]
>>>>>>>>>>>>>>>>>>>]
<<<<<<<<<<<<<<<<<<<]
>>>>>>>>>[+[+[+[+[+[+[+[+[+[+[[-]<+>]]]]]]]]]]]<
]
>>>>>>>>
[ subtract divisor from dividend
<<<<<<
[>>>>>>>>[-]>[-]<<<<<[->>>+>+<<<<]>>>>>>]<<<<<<<<<<
[>>>>>>>>[-<<<<+>>>>]<<<[->>>+>+<<<<]<<<<<<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>>>[-<<<<+>>>>]>]<<<<<<<<<<
[>>>>>>>>[-<->]<<<<<<<<<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
[++++++++++[+>-<]>>>>>>>>>>-<<<<<<<<<<]]]]]]]]]]]>>>]
>>>>>>>+
[ if difference is nonnegative then
[-]<<<<<<<<<<<<<<<<< replace dividend and increment quotient
[>>>>[-]>>>>[-<<<<+>>>>]<<[->>+<<]<<<<<<<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>>[->+<<<+>>]>>]<<<<<<<<<<
[>>>[->>>>>>+<<<<<<]<<<<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>>>[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
[-<<<<<<+>>>>>>[-<<<<<<--------->>>>>>>>>>>>>>>>+<<<<<<<<<<
[-<<<<<<+>>>>>>]]]]]]]]]]]>]
>>>>>>>
] halve divisor and loop until zero
<<<<<<<<<<<<<<<<<[<<<<<<<<<<]>>>>>>>>>>
[>>>>>>>>[-]<<[->+<]<[->>>+<<<]>>>>>]<<<<<<<<<<
[+>>>>>>>[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
[-<<<<<<<+>>>>>>>]]]]]]]]]<<<<<<<
[->>>>>>>+<<<<<<<]-<<<<<<<<<<]
>>>>>>>
[-<<<<<<<<<<<+>>>>>>>>>>>]
>>>[>>>>>>>[-<<<<<<<<<<<+++++>>>>>>>>>>>]>>>]<<<<<<<<<<
[+>>>>>>>>[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
[-<<<<<<<<+>>>>>>>>]]]]]]]]]<<<<<<<<
[->>>>>>>>+<<<<<<<<]-<<<<<<<<<<]
>>>>>>>>[-<<<<<<<<<<<<<+>>>>>>>>>>>>>]>>
[>>>>>>>>[-<<<<<<<<<<<<<+++++>>>>>>>>>>>>>]>>]<<<<<<<<<<
[<<<<<<<<<<]>>>>>>>>>>
>>>>>>
]
<<<<<<
*
* make copies of the loop variable and the quotient
*
[>>>[->>>>+>+<<<<<]>>>>>>>]
<<<<<<<<<<
[>>>>>>>[-<<<<+>>>>]<<<<<[->>>>>+>>+<<<<<<<]<<<<<<<<<<<<]
>>>>>>>>>>[>>>>>>>[-<<<<<+>>>>>]>>>]<<<<<<<<<<
*
* break out of the loop if the quotient is larger than the loop variable
*
[>>>>>>>>>[-<->]<
[<<<<<<<<
[<<[-]>>>>>>>>>>[-<<<<<<<<<<+>>>>>>>>>>]<<<<<<<<<<<<<<<<<<]
>>>>>>>>>>>>>>>>>>]<<<<<<<<<<<<<<<<<<]
>>>>>>>>[>-<[+[+[+[+[+[+[+[+[+[[-]>+<]]]]]]]]]]]>+
[ [-]
*
* partially increment the loop variable
*
<[-]+>>>>+>>>>>>>>[>>>>>>>>>>]<<<<<<<<<<
*
* examine the remainder for nonzero digits
*
[<<<<<<[<<<<[<<<<<<<<<<]>>>>+<<<<<<<<<<]<<<<]
>>>>>>>>>>>>>>>>>>>>[>>>>>>>>>>]<<<<<<<<<<[<<<<<<<<<<]
>>>>-
[ [+]
*
* decrement the loop variable and replace the number with the quotient
*
>>>>>>>>-<<[>[-]>>[-<<+>>]>>>>>>>]<<<<<<<<<<
*
* display the loop variable
*
[+>>[>>>>>>>>+>>]<<-<<<<<<<<<<]-
[>>++++++++++++++++++++++++++++++++++++++++++++++++.
------------------------------------------------<<<<<<<<<<<<]
++++++++++++++++++++++++++++++++.[-]>>>>
]
*
* normalize the loop variable
*
>>>>>>
[>>[->>>>>+<<<<<[->>>>>+<<<<<
[->>>>>+<<<<<[->>>>>+<<<<<
[->>>>>+<<<<<[->>>>>+<<<<<
[->>>>>+<<<<<[->>>>>+<<<<<
[->>>>>+<<<<<[->>>>>--------->>>>>+<<<<<<<<<<
[->>>>>+<<<<<]]]]]]]]]]]>>>>>>>>]
<<<<<<<<<<[>>>>>>>[-<<<<<+>>>>>]<<<<<<<<<<<<<<<<<]
>>>>>>>>>
]<
]>>
*
* display the number and end
*
[>>>>>>>>>>]<<<<<<<<<<[+>[>>>>>>>>>+>]<-<<<<<<<<<<]-
[>++++++++++++++++++++++++++++++++++++++++++++++++.<<<<<<<<<<<]
++++++++++.
joel=#* select * from llvmir;
programid|3
llvmir|
; >ENTER_PROGRAM 4300
define i32 @__llvmjit(i8* %memory, i32* %dataptr_addr) {
entry:
;ENTRY
; <ENTER_PROGRAM 4300
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4068
%dataptr_enter_4068 = load i32, i32* %dataptr_addr
%element_addr_enter_4068 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4068
%element_enter_4068 = load i8, i8* %element_addr_enter_4068
%compare_zero_enter_4068 = icmp eq i8 %element_enter_4068, 0
br i1 %compare_zero_enter_4068, label %post_loop_4068, label %loop_body_4068
loop_body_4068:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4068
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4068
%dataptr_leave_4068 = load i32, i32* %dataptr_addr
%element_addr_leave_4068 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4068
%element_leave_4068 = load i8, i8* %element_addr_leave_4068
%compare_zero_leave_4068 = icmp ne i8 %element_leave_4068, 0
br i1 %compare_zero_leave_4068, label %loop_body_4068, label %post_loop_4068
post_loop_4068:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4068
; >ENTER_INC_PTR 66
%dataptr_66 = load i32, i32* %dataptr_addr
%inc_dataptr_66 = add i32 %dataptr_66, 30
store i32 %inc_dataptr_66, i32* %dataptr_addr
; <ENTER_INC_PTR 66
; >ENTER_DEC_DATA 96
%dataptr_96 = load i32, i32* %dataptr_addr
%element_addr_96 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_96
%element_96 = load i8, i8* %element_addr_96
%sub_element_96 = sub i8 %element_96, 1
store i8 %sub_element_96, i8* %element_addr_96
; <ENTER_DEC_DATA 96
; >ENTER_DEC_PTR 98
%dataptr_98 = load i32, i32* %dataptr_addr
%dec_dataptr_98 = sub i32 %dataptr_98, 9
store i32 %dec_dataptr_98, i32* %dataptr_addr
; <ENTER_DEC_PTR 98
; >ENTER_INC_DATA 107
%dataptr_107 = load i32, i32* %dataptr_addr
%element_addr_107 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_107
%element_107 = load i8, i8* %element_addr_107
%inc_element_107 = add i8 %element_107, 1
store i8 %inc_element_107, i8* %element_addr_107
; <ENTER_INC_DATA 107
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4073
%dataptr_enter_4073 = load i32, i32* %dataptr_addr
%element_addr_enter_4073 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4073
%element_enter_4073 = load i8, i8* %element_addr_enter_4073
%compare_zero_enter_4073 = icmp eq i8 %element_enter_4073, 0
br i1 %compare_zero_enter_4073, label %post_loop_4073, label %loop_body_4073
loop_body_4073:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4073
; >ENTER_DEC_DATA 110
%dataptr_110 = load i32, i32* %dataptr_addr
%element_addr_110 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_110
%element_110 = load i8, i8* %element_addr_110
%sub_element_110 = sub i8 %element_110, 1
store i8 %sub_element_110, i8* %element_addr_110
; <ENTER_DEC_DATA 110
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4069
%dataptr_enter_4069 = load i32, i32* %dataptr_addr
%element_addr_enter_4069 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4069
%element_enter_4069 = load i8, i8* %element_addr_enter_4069
%compare_zero_enter_4069 = icmp eq i8 %element_enter_4069, 0
br i1 %compare_zero_enter_4069, label %post_loop_4069, label %loop_body_4069
loop_body_4069:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4069
; >ENTER_INC_PTR 112
%dataptr_112 = load i32, i32* %dataptr_addr
%inc_dataptr_112 = add i32 %dataptr_112, 10
store i32 %inc_dataptr_112, i32* %dataptr_addr
; <ENTER_INC_PTR 112
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4069
%dataptr_leave_4069 = load i32, i32* %dataptr_addr
%element_addr_leave_4069 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4069
%element_leave_4069 = load i8, i8* %element_addr_leave_4069
%compare_zero_leave_4069 = icmp ne i8 %element_leave_4069, 0
br i1 %compare_zero_leave_4069, label %loop_body_4069, label %post_loop_4069
post_loop_4069:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4069
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4070
%dataptr_enter_4070 = load i32, i32* %dataptr_addr
%element_addr_enter_4070 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4070
%element_enter_4070 = load i8, i8* %element_addr_enter_4070
%compare_zero_enter_4070 = icmp eq i8 %element_enter_4070, 0
br i1 %compare_zero_enter_4070, label %post_loop_4070, label %loop_body_4070
loop_body_4070:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4070
; >ENTER_DEC_DATA 124
%dataptr_124 = load i32, i32* %dataptr_addr
%element_addr_124 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_124
%element_124 = load i8, i8* %element_addr_124
%sub_element_124 = sub i8 %element_124, 1
store i8 %sub_element_124, i8* %element_addr_124
; <ENTER_DEC_DATA 124
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4070
%dataptr_leave_4070 = load i32, i32* %dataptr_addr
%element_addr_leave_4070 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4070
%element_leave_4070 = load i8, i8* %element_addr_leave_4070
%compare_zero_leave_4070 = icmp ne i8 %element_leave_4070, 0
br i1 %compare_zero_leave_4070, label %loop_body_4070, label %post_loop_4070
post_loop_4070:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4070
; >ENTER_DEC_PTR 126
%dataptr_126 = load i32, i32* %dataptr_addr
%dec_dataptr_126 = sub i32 %dataptr_126, 10
store i32 %dec_dataptr_126, i32* %dataptr_addr
; <ENTER_DEC_PTR 126
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4072
%dataptr_enter_4072 = load i32, i32* %dataptr_addr
%element_addr_enter_4072 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4072
%element_enter_4072 = load i8, i8* %element_addr_enter_4072
%compare_zero_enter_4072 = icmp eq i8 %element_enter_4072, 0
br i1 %compare_zero_enter_4072, label %post_loop_4072, label %loop_body_4072
loop_body_4072:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4072
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4071
%dataptr_enter_4071 = load i32, i32* %dataptr_addr
%element_addr_enter_4071 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4071
%element_enter_4071 = load i8, i8* %element_addr_enter_4071
%compare_zero_enter_4071 = icmp eq i8 %element_enter_4071, 0
br i1 %compare_zero_enter_4071, label %post_loop_4071, label %loop_body_4071
loop_body_4071:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4071
; >ENTER_DEC_DATA 138
%dataptr_138 = load i32, i32* %dataptr_addr
%element_addr_138 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_138
%element_138 = load i8, i8* %element_addr_138
%sub_element_138 = sub i8 %element_138, 1
store i8 %sub_element_138, i8* %element_addr_138
; <ENTER_DEC_DATA 138
; >ENTER_INC_PTR 139
%dataptr_139 = load i32, i32* %dataptr_addr
%inc_dataptr_139 = add i32 %dataptr_139, 10
store i32 %inc_dataptr_139, i32* %dataptr_addr
; <ENTER_INC_PTR 139
; >ENTER_INC_DATA 149
%dataptr_149 = load i32, i32* %dataptr_addr
%element_addr_149 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_149
%element_149 = load i8, i8* %element_addr_149
%inc_element_149 = add i8 %element_149, 1
store i8 %inc_element_149, i8* %element_addr_149
; <ENTER_INC_DATA 149
; >ENTER_DEC_PTR 150
%dataptr_150 = load i32, i32* %dataptr_addr
%dec_dataptr_150 = sub i32 %dataptr_150, 10
store i32 %dec_dataptr_150, i32* %dataptr_addr
; <ENTER_DEC_PTR 150
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4071
%dataptr_leave_4071 = load i32, i32* %dataptr_addr
%element_addr_leave_4071 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4071
%element_leave_4071 = load i8, i8* %element_addr_leave_4071
%compare_zero_leave_4071 = icmp ne i8 %element_leave_4071, 0
br i1 %compare_zero_leave_4071, label %loop_body_4071, label %post_loop_4071
post_loop_4071:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4071
; >ENTER_DEC_PTR 161
%dataptr_161 = load i32, i32* %dataptr_addr
%dec_dataptr_161 = sub i32 %dataptr_161, 10
store i32 %dec_dataptr_161, i32* %dataptr_addr
; <ENTER_DEC_PTR 161
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4072
%dataptr_leave_4072 = load i32, i32* %dataptr_addr
%element_addr_leave_4072 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4072
%element_leave_4072 = load i8, i8* %element_addr_leave_4072
%compare_zero_leave_4072 = icmp ne i8 %element_leave_4072, 0
br i1 %compare_zero_leave_4072, label %loop_body_4072, label %post_loop_4072
post_loop_4072:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4072
; >ENTER_INC_PTR 173
%dataptr_173 = load i32, i32* %dataptr_addr
%inc_dataptr_173 = add i32 %dataptr_173, 10
store i32 %inc_dataptr_173, i32* %dataptr_addr
; <ENTER_INC_PTR 173
; >ENTER_READ_STDIN 183
ret i32 183
post_183:
; <ENTER_READ_STDIN 183
; >ENTER_DEC_DATA 184
%dataptr_184 = load i32, i32* %dataptr_addr
%element_addr_184 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_184
%element_184 = load i8, i8* %element_addr_184
%sub_element_184 = sub i8 %element_184, 10
store i8 %sub_element_184, i8* %element_addr_184
; <ENTER_DEC_DATA 184
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4073
%dataptr_leave_4073 = load i32, i32* %dataptr_addr
%element_addr_leave_4073 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4073
%element_leave_4073 = load i8, i8* %element_addr_leave_4073
%compare_zero_leave_4073 = icmp ne i8 %element_leave_4073, 0
br i1 %compare_zero_leave_4073, label %loop_body_4073, label %post_loop_4073
post_loop_4073:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4073
; >ENTER_INC_PTR 196
%dataptr_196 = load i32, i32* %dataptr_addr
%inc_dataptr_196 = add i32 %dataptr_196, 10
store i32 %inc_dataptr_196, i32* %dataptr_addr
; <ENTER_INC_PTR 196
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4074
%dataptr_enter_4074 = load i32, i32* %dataptr_addr
%element_addr_enter_4074 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4074
%element_enter_4074 = load i8, i8* %element_addr_enter_4074
%compare_zero_enter_4074 = icmp eq i8 %element_enter_4074, 0
br i1 %compare_zero_enter_4074, label %post_loop_4074, label %loop_body_4074
loop_body_4074:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4074
; >ENTER_DEC_DATA 207
%dataptr_207 = load i32, i32* %dataptr_addr
%element_addr_207 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_207
%element_207 = load i8, i8* %element_addr_207
%sub_element_207 = sub i8 %element_207, 37
store i8 %sub_element_207, i8* %element_addr_207
; <ENTER_DEC_DATA 207
; >ENTER_INC_PTR 244
%dataptr_244 = load i32, i32* %dataptr_addr
%inc_dataptr_244 = add i32 %dataptr_244, 9
store i32 %inc_dataptr_244, i32* %dataptr_addr
; <ENTER_INC_PTR 244
; >ENTER_DEC_DATA 253
%dataptr_253 = load i32, i32* %dataptr_addr
%element_addr_253 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_253
%element_253 = load i8, i8* %element_addr_253
%sub_element_253 = sub i8 %element_253, 1
store i8 %sub_element_253, i8* %element_addr_253
; <ENTER_DEC_DATA 253
; >ENTER_INC_PTR 254
%dataptr_254 = load i32, i32* %dataptr_addr
%inc_dataptr_254 = add i32 %dataptr_254, 1
store i32 %inc_dataptr_254, i32* %dataptr_addr
; <ENTER_INC_PTR 254
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4074
%dataptr_leave_4074 = load i32, i32* %dataptr_addr
%element_addr_leave_4074 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4074
%element_leave_4074 = load i8, i8* %element_addr_leave_4074
%compare_zero_leave_4074 = icmp ne i8 %element_leave_4074, 0
br i1 %compare_zero_leave_4074, label %loop_body_4074, label %post_loop_4074
post_loop_4074:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4074
; >ENTER_DEC_PTR 257
%dataptr_257 = load i32, i32* %dataptr_addr
%dec_dataptr_257 = sub i32 %dataptr_257, 1
store i32 %dec_dataptr_257, i32* %dataptr_addr
; <ENTER_DEC_PTR 257
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4076
%dataptr_enter_4076 = load i32, i32* %dataptr_addr
%element_addr_enter_4076 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4076
%element_enter_4076 = load i8, i8* %element_addr_enter_4076
%compare_zero_enter_4076 = icmp eq i8 %element_enter_4076, 0
br i1 %compare_zero_enter_4076, label %post_loop_4076, label %loop_body_4076
loop_body_4076:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4076
; >ENTER_INC_DATA 259
%dataptr_259 = load i32, i32* %dataptr_addr
%element_addr_259 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_259
%element_259 = load i8, i8* %element_addr_259
%inc_element_259 = add i8 %element_259, 1
store i8 %inc_element_259, i8* %element_addr_259
; <ENTER_INC_DATA 259
; >ENTER_INC_PTR 260
%dataptr_260 = load i32, i32* %dataptr_addr
%inc_dataptr_260 = add i32 %dataptr_260, 1
store i32 %inc_dataptr_260, i32* %dataptr_addr
; <ENTER_INC_PTR 260
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4075
%dataptr_enter_4075 = load i32, i32* %dataptr_addr
%element_addr_enter_4075 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4075
%element_enter_4075 = load i8, i8* %element_addr_enter_4075
%compare_zero_enter_4075 = icmp eq i8 %element_enter_4075, 0
br i1 %compare_zero_enter_4075, label %post_loop_4075, label %loop_body_4075
loop_body_4075:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4075
; >ENTER_INC_PTR 262
%dataptr_262 = load i32, i32* %dataptr_addr
%inc_dataptr_262 = add i32 %dataptr_262, 9
store i32 %inc_dataptr_262, i32* %dataptr_addr
; <ENTER_INC_PTR 262
; >ENTER_INC_DATA 271
%dataptr_271 = load i32, i32* %dataptr_addr
%element_addr_271 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_271
%element_271 = load i8, i8* %element_addr_271
%inc_element_271 = add i8 %element_271, 1
store i8 %inc_element_271, i8* %element_addr_271
; <ENTER_INC_DATA 271
; >ENTER_INC_PTR 272
%dataptr_272 = load i32, i32* %dataptr_addr
%inc_dataptr_272 = add i32 %dataptr_272, 1
store i32 %inc_dataptr_272, i32* %dataptr_addr
; <ENTER_INC_PTR 272
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4075
%dataptr_leave_4075 = load i32, i32* %dataptr_addr
%element_addr_leave_4075 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4075
%element_leave_4075 = load i8, i8* %element_addr_leave_4075
%compare_zero_leave_4075 = icmp ne i8 %element_leave_4075, 0
br i1 %compare_zero_leave_4075, label %loop_body_4075, label %post_loop_4075
post_loop_4075:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4075
; >ENTER_DEC_PTR 274
%dataptr_274 = load i32, i32* %dataptr_addr
%dec_dataptr_274 = sub i32 %dataptr_274, 1
store i32 %dec_dataptr_274, i32* %dataptr_addr
; <ENTER_DEC_PTR 274
; >ENTER_DEC_DATA 275
%dataptr_275 = load i32, i32* %dataptr_addr
%element_addr_275 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_275
%element_275 = load i8, i8* %element_addr_275
%sub_element_275 = sub i8 %element_275, 1
store i8 %sub_element_275, i8* %element_addr_275
; <ENTER_DEC_DATA 275
; >ENTER_DEC_PTR 276
%dataptr_276 = load i32, i32* %dataptr_addr
%dec_dataptr_276 = sub i32 %dataptr_276, 10
store i32 %dec_dataptr_276, i32* %dataptr_addr
; <ENTER_DEC_PTR 276
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4076
%dataptr_leave_4076 = load i32, i32* %dataptr_addr
%element_addr_leave_4076 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4076
%element_leave_4076 = load i8, i8* %element_addr_leave_4076
%compare_zero_leave_4076 = icmp ne i8 %element_leave_4076, 0
br i1 %compare_zero_leave_4076, label %loop_body_4076, label %post_loop_4076
post_loop_4076:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4076
; >ENTER_DEC_DATA 287
%dataptr_287 = load i32, i32* %dataptr_addr
%element_addr_287 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_287
%element_287 = load i8, i8* %element_addr_287
%sub_element_287 = sub i8 %element_287, 1
store i8 %sub_element_287, i8* %element_addr_287
; <ENTER_DEC_DATA 287
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4077
%dataptr_enter_4077 = load i32, i32* %dataptr_addr
%element_addr_enter_4077 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4077
%element_enter_4077 = load i8, i8* %element_addr_enter_4077
%compare_zero_enter_4077 = icmp eq i8 %element_enter_4077, 0
br i1 %compare_zero_enter_4077, label %post_loop_4077, label %loop_body_4077
loop_body_4077:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4077
; >ENTER_INC_PTR 290
%dataptr_290 = load i32, i32* %dataptr_addr
%inc_dataptr_290 = add i32 %dataptr_290, 1
store i32 %inc_dataptr_290, i32* %dataptr_addr
; <ENTER_INC_PTR 290
; >ENTER_INC_DATA 291
%dataptr_291 = load i32, i32* %dataptr_addr
%element_addr_291 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_291
%element_291 = load i8, i8* %element_addr_291
%inc_element_291 = add i8 %element_291, 48
store i8 %inc_element_291, i8* %element_addr_291
; <ENTER_INC_DATA 291
; >ENTER_WRITE_STDOUT 339
ret i32 339
post_339:
; <ENTER_WRITE_STDOUT 339
; >ENTER_DEC_DATA 341
%dataptr_341 = load i32, i32* %dataptr_addr
%element_addr_341 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_341
%element_341 = load i8, i8* %element_addr_341
%sub_element_341 = sub i8 %element_341, 48
store i8 %sub_element_341, i8* %element_addr_341
; <ENTER_DEC_DATA 341
; >ENTER_DEC_PTR 389
%dataptr_389 = load i32, i32* %dataptr_addr
%dec_dataptr_389 = sub i32 %dataptr_389, 11
store i32 %dec_dataptr_389, i32* %dataptr_addr
; <ENTER_DEC_PTR 389
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4077
%dataptr_leave_4077 = load i32, i32* %dataptr_addr
%element_addr_leave_4077 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4077
%element_leave_4077 = load i8, i8* %element_addr_leave_4077
%compare_zero_leave_4077 = icmp ne i8 %element_leave_4077, 0
br i1 %compare_zero_leave_4077, label %loop_body_4077, label %post_loop_4077
post_loop_4077:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4077
; >ENTER_INC_DATA 402
%dataptr_402 = load i32, i32* %dataptr_addr
%element_addr_402 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_402
%element_402 = load i8, i8* %element_addr_402
%inc_element_402 = add i8 %element_402, 58
store i8 %inc_element_402, i8* %element_addr_402
; <ENTER_INC_DATA 402
; >ENTER_WRITE_STDOUT 460
ret i32 460
post_460:
; <ENTER_WRITE_STDOUT 460
; >ENTER_DEC_DATA 462
%dataptr_462 = load i32, i32* %dataptr_addr
%element_addr_462 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_462
%element_462 = load i8, i8* %element_addr_462
%sub_element_462 = sub i8 %element_462, 26
store i8 %sub_element_462, i8* %element_addr_462
; <ENTER_DEC_DATA 462
; >ENTER_WRITE_STDOUT 488
ret i32 488
post_488:
; <ENTER_WRITE_STDOUT 488
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4078
%dataptr_enter_4078 = load i32, i32* %dataptr_addr
%element_addr_enter_4078 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4078
%element_enter_4078 = load i8, i8* %element_addr_enter_4078
%compare_zero_enter_4078 = icmp eq i8 %element_enter_4078, 0
br i1 %compare_zero_enter_4078, label %post_loop_4078, label %loop_body_4078
loop_body_4078:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4078
; >ENTER_DEC_DATA 490
%dataptr_490 = load i32, i32* %dataptr_addr
%element_addr_490 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_490
%element_490 = load i8, i8* %element_addr_490
%sub_element_490 = sub i8 %element_490, 1
store i8 %sub_element_490, i8* %element_addr_490
; <ENTER_DEC_DATA 490
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4078
%dataptr_leave_4078 = load i32, i32* %dataptr_addr
%element_addr_leave_4078 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4078
%element_leave_4078 = load i8, i8* %element_addr_leave_4078
%compare_zero_leave_4078 = icmp ne i8 %element_leave_4078, 0
br i1 %compare_zero_leave_4078, label %loop_body_4078, label %post_loop_4078
post_loop_4078:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4078
; >ENTER_INC_PTR 493
%dataptr_493 = load i32, i32* %dataptr_addr
%inc_dataptr_493 = add i32 %dataptr_493, 12
store i32 %inc_dataptr_493, i32* %dataptr_addr
; <ENTER_INC_PTR 493
; >ENTER_INC_DATA 505
%dataptr_505 = load i32, i32* %dataptr_addr
%element_addr_505 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_505
%element_505 = load i8, i8* %element_addr_505
%inc_element_505 = add i8 %element_505, 2
store i8 %inc_element_505, i8* %element_addr_505
; <ENTER_INC_DATA 505
; >ENTER_DEC_PTR 507
%dataptr_507 = load i32, i32* %dataptr_addr
%dec_dataptr_507 = sub i32 %dataptr_507, 4
store i32 %dec_dataptr_507, i32* %dataptr_addr
; <ENTER_DEC_PTR 507
; >ENTER_INC_DATA 511
%dataptr_511 = load i32, i32* %dataptr_addr
%element_addr_511 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_511
%element_511 = load i8, i8* %element_addr_511
%inc_element_511 = add i8 %element_511, 1
store i8 %inc_element_511, i8* %element_addr_511
; <ENTER_INC_DATA 511
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4294
%dataptr_enter_4294 = load i32, i32* %dataptr_addr
%element_addr_enter_4294 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4294
%element_enter_4294 = load i8, i8* %element_addr_enter_4294
%compare_zero_enter_4294 = icmp eq i8 %element_enter_4294, 0
br i1 %compare_zero_enter_4294, label %post_loop_4294, label %loop_body_4294
loop_body_4294:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4294
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4079
%dataptr_enter_4079 = load i32, i32* %dataptr_addr
%element_addr_enter_4079 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4079
%element_enter_4079 = load i8, i8* %element_addr_enter_4079
%compare_zero_enter_4079 = icmp eq i8 %element_enter_4079, 0
br i1 %compare_zero_enter_4079, label %post_loop_4079, label %loop_body_4079
loop_body_4079:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4079
; >ENTER_DEC_DATA 516
%dataptr_516 = load i32, i32* %dataptr_addr
%element_addr_516 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_516
%element_516 = load i8, i8* %element_addr_516
%sub_element_516 = sub i8 %element_516, 1
store i8 %sub_element_516, i8* %element_addr_516
; <ENTER_DEC_DATA 516
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4079
%dataptr_leave_4079 = load i32, i32* %dataptr_addr
%element_addr_leave_4079 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4079
%element_leave_4079 = load i8, i8* %element_addr_leave_4079
%compare_zero_leave_4079 = icmp ne i8 %element_leave_4079, 0
br i1 %compare_zero_leave_4079, label %loop_body_4079, label %post_loop_4079
post_loop_4079:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4079
; >ENTER_INC_PTR 518
%dataptr_518 = load i32, i32* %dataptr_addr
%inc_dataptr_518 = add i32 %dataptr_518, 2
store i32 %inc_dataptr_518, i32* %dataptr_addr
; <ENTER_INC_PTR 518
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4087
%dataptr_enter_4087 = load i32, i32* %dataptr_addr
%element_addr_enter_4087 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4087
%element_enter_4087 = load i8, i8* %element_addr_enter_4087
%compare_zero_enter_4087 = icmp eq i8 %element_enter_4087, 0
br i1 %compare_zero_enter_4087, label %post_loop_4087, label %loop_body_4087
loop_body_4087:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4087
; >ENTER_INC_PTR 522
%dataptr_522 = load i32, i32* %dataptr_addr
%inc_dataptr_522 = add i32 %dataptr_522, 4
store i32 %inc_dataptr_522, i32* %dataptr_addr
; <ENTER_INC_PTR 522
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4080
%dataptr_enter_4080 = load i32, i32* %dataptr_addr
%element_addr_enter_4080 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4080
%element_enter_4080 = load i8, i8* %element_addr_enter_4080
%compare_zero_enter_4080 = icmp eq i8 %element_enter_4080, 0
br i1 %compare_zero_enter_4080, label %post_loop_4080, label %loop_body_4080
loop_body_4080:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4080
; >ENTER_DEC_DATA 527
%dataptr_527 = load i32, i32* %dataptr_addr
%element_addr_527 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_527
%element_527 = load i8, i8* %element_addr_527
%sub_element_527 = sub i8 %element_527, 1
store i8 %sub_element_527, i8* %element_addr_527
; <ENTER_DEC_DATA 527
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4080
%dataptr_leave_4080 = load i32, i32* %dataptr_addr
%element_addr_leave_4080 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4080
%element_leave_4080 = load i8, i8* %element_addr_leave_4080
%compare_zero_leave_4080 = icmp ne i8 %element_leave_4080, 0
br i1 %compare_zero_leave_4080, label %loop_body_4080, label %post_loop_4080
post_loop_4080:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4080
; >ENTER_INC_PTR 529
%dataptr_529 = load i32, i32* %dataptr_addr
%inc_dataptr_529 = add i32 %dataptr_529, 1
store i32 %inc_dataptr_529, i32* %dataptr_addr
; <ENTER_INC_PTR 529
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4081
%dataptr_enter_4081 = load i32, i32* %dataptr_addr
%element_addr_enter_4081 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4081
%element_enter_4081 = load i8, i8* %element_addr_enter_4081
%compare_zero_enter_4081 = icmp eq i8 %element_enter_4081, 0
br i1 %compare_zero_enter_4081, label %post_loop_4081, label %loop_body_4081
loop_body_4081:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4081
; >ENTER_DEC_DATA 531
%dataptr_531 = load i32, i32* %dataptr_addr
%element_addr_531 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_531
%element_531 = load i8, i8* %element_addr_531
%sub_element_531 = sub i8 %element_531, 1
store i8 %sub_element_531, i8* %element_addr_531
; <ENTER_DEC_DATA 531
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4081
%dataptr_leave_4081 = load i32, i32* %dataptr_addr
%element_addr_leave_4081 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4081
%element_leave_4081 = load i8, i8* %element_addr_leave_4081
%compare_zero_leave_4081 = icmp ne i8 %element_leave_4081, 0
br i1 %compare_zero_leave_4081, label %loop_body_4081, label %post_loop_4081
post_loop_4081:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4081
; >ENTER_INC_PTR 533
%dataptr_533 = load i32, i32* %dataptr_addr
%inc_dataptr_533 = add i32 %dataptr_533, 1
store i32 %inc_dataptr_533, i32* %dataptr_addr
; <ENTER_INC_PTR 533
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4082
%dataptr_enter_4082 = load i32, i32* %dataptr_addr
%element_addr_enter_4082 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4082
%element_enter_4082 = load i8, i8* %element_addr_enter_4082
%compare_zero_enter_4082 = icmp eq i8 %element_enter_4082, 0
br i1 %compare_zero_enter_4082, label %post_loop_4082, label %loop_body_4082
loop_body_4082:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4082
; >ENTER_DEC_DATA 535
%dataptr_535 = load i32, i32* %dataptr_addr
%element_addr_535 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_535
%element_535 = load i8, i8* %element_addr_535
%sub_element_535 = sub i8 %element_535, 1
store i8 %sub_element_535, i8* %element_addr_535
; <ENTER_DEC_DATA 535
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4082
%dataptr_leave_4082 = load i32, i32* %dataptr_addr
%element_addr_leave_4082 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4082
%element_leave_4082 = load i8, i8* %element_addr_leave_4082
%compare_zero_leave_4082 = icmp ne i8 %element_leave_4082, 0
br i1 %compare_zero_leave_4082, label %loop_body_4082, label %post_loop_4082
post_loop_4082:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4082
; >ENTER_INC_PTR 537
%dataptr_537 = load i32, i32* %dataptr_addr
%inc_dataptr_537 = add i32 %dataptr_537, 1
store i32 %inc_dataptr_537, i32* %dataptr_addr
; <ENTER_INC_PTR 537
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4083
%dataptr_enter_4083 = load i32, i32* %dataptr_addr
%element_addr_enter_4083 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4083
%element_enter_4083 = load i8, i8* %element_addr_enter_4083
%compare_zero_enter_4083 = icmp eq i8 %element_enter_4083, 0
br i1 %compare_zero_enter_4083, label %post_loop_4083, label %loop_body_4083
loop_body_4083:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4083
; >ENTER_DEC_DATA 539
%dataptr_539 = load i32, i32* %dataptr_addr
%element_addr_539 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_539
%element_539 = load i8, i8* %element_addr_539
%sub_element_539 = sub i8 %element_539, 1
store i8 %sub_element_539, i8* %element_addr_539
; <ENTER_DEC_DATA 539
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4083
%dataptr_leave_4083 = load i32, i32* %dataptr_addr
%element_addr_leave_4083 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4083
%element_leave_4083 = load i8, i8* %element_addr_leave_4083
%compare_zero_leave_4083 = icmp ne i8 %element_leave_4083, 0
br i1 %compare_zero_leave_4083, label %loop_body_4083, label %post_loop_4083
post_loop_4083:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4083
; >ENTER_INC_PTR 542
%dataptr_542 = load i32, i32* %dataptr_addr
%inc_dataptr_542 = add i32 %dataptr_542, 1
store i32 %inc_dataptr_542, i32* %dataptr_addr
; <ENTER_INC_PTR 542
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4084
%dataptr_enter_4084 = load i32, i32* %dataptr_addr
%element_addr_enter_4084 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4084
%element_enter_4084 = load i8, i8* %element_addr_enter_4084
%compare_zero_enter_4084 = icmp eq i8 %element_enter_4084, 0
br i1 %compare_zero_enter_4084, label %post_loop_4084, label %loop_body_4084
loop_body_4084:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4084
; >ENTER_DEC_DATA 544
%dataptr_544 = load i32, i32* %dataptr_addr
%element_addr_544 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_544
%element_544 = load i8, i8* %element_addr_544
%sub_element_544 = sub i8 %element_544, 1
store i8 %sub_element_544, i8* %element_addr_544
; <ENTER_DEC_DATA 544
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4084
%dataptr_leave_4084 = load i32, i32* %dataptr_addr
%element_addr_leave_4084 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4084
%element_leave_4084 = load i8, i8* %element_addr_leave_4084
%compare_zero_leave_4084 = icmp ne i8 %element_leave_4084, 0
br i1 %compare_zero_leave_4084, label %loop_body_4084, label %post_loop_4084
post_loop_4084:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4084
; >ENTER_INC_PTR 546
%dataptr_546 = load i32, i32* %dataptr_addr
%inc_dataptr_546 = add i32 %dataptr_546, 1
store i32 %inc_dataptr_546, i32* %dataptr_addr
; <ENTER_INC_PTR 546
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4085
%dataptr_enter_4085 = load i32, i32* %dataptr_addr
%element_addr_enter_4085 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4085
%element_enter_4085 = load i8, i8* %element_addr_enter_4085
%compare_zero_enter_4085 = icmp eq i8 %element_enter_4085, 0
br i1 %compare_zero_enter_4085, label %post_loop_4085, label %loop_body_4085
loop_body_4085:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4085
; >ENTER_DEC_DATA 548
%dataptr_548 = load i32, i32* %dataptr_addr
%element_addr_548 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_548
%element_548 = load i8, i8* %element_addr_548
%sub_element_548 = sub i8 %element_548, 1
store i8 %sub_element_548, i8* %element_addr_548
; <ENTER_DEC_DATA 548
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4085
%dataptr_leave_4085 = load i32, i32* %dataptr_addr
%element_addr_leave_4085 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4085
%element_leave_4085 = load i8, i8* %element_addr_leave_4085
%compare_zero_leave_4085 = icmp ne i8 %element_leave_4085, 0
br i1 %compare_zero_leave_4085, label %loop_body_4085, label %post_loop_4085
post_loop_4085:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4085
; >ENTER_DEC_PTR 551
%dataptr_551 = load i32, i32* %dataptr_addr
%dec_dataptr_551 = sub i32 %dataptr_551, 7
store i32 %dec_dataptr_551, i32* %dataptr_addr
; <ENTER_DEC_PTR 551
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4086
%dataptr_enter_4086 = load i32, i32* %dataptr_addr
%element_addr_enter_4086 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4086
%element_enter_4086 = load i8, i8* %element_addr_enter_4086
%compare_zero_enter_4086 = icmp eq i8 %element_enter_4086, 0
br i1 %compare_zero_enter_4086, label %post_loop_4086, label %loop_body_4086
loop_body_4086:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4086
; >ENTER_DEC_DATA 559
%dataptr_559 = load i32, i32* %dataptr_addr
%element_addr_559 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_559
%element_559 = load i8, i8* %element_addr_559
%sub_element_559 = sub i8 %element_559, 1
store i8 %sub_element_559, i8* %element_addr_559
; <ENTER_DEC_DATA 559
; >ENTER_INC_PTR 560
%dataptr_560 = load i32, i32* %dataptr_addr
%inc_dataptr_560 = add i32 %dataptr_560, 3
store i32 %inc_dataptr_560, i32* %dataptr_addr
; <ENTER_INC_PTR 560
; >ENTER_INC_DATA 563
%dataptr_563 = load i32, i32* %dataptr_addr
%element_addr_563 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_563
%element_563 = load i8, i8* %element_addr_563
%inc_element_563 = add i8 %element_563, 1
store i8 %inc_element_563, i8* %element_addr_563
; <ENTER_INC_DATA 563
; >ENTER_INC_PTR 564
%dataptr_564 = load i32, i32* %dataptr_addr
%inc_dataptr_564 = add i32 %dataptr_564, 1
store i32 %inc_dataptr_564, i32* %dataptr_addr
; <ENTER_INC_PTR 564
; >ENTER_INC_DATA 565
%dataptr_565 = load i32, i32* %dataptr_addr
%element_addr_565 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_565
%element_565 = load i8, i8* %element_addr_565
%inc_element_565 = add i8 %element_565, 1
store i8 %inc_element_565, i8* %element_addr_565
; <ENTER_INC_DATA 565
; >ENTER_DEC_PTR 566
%dataptr_566 = load i32, i32* %dataptr_addr
%dec_dataptr_566 = sub i32 %dataptr_566, 4
store i32 %dec_dataptr_566, i32* %dataptr_addr
; <ENTER_DEC_PTR 566
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4086
%dataptr_leave_4086 = load i32, i32* %dataptr_addr
%element_addr_leave_4086 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4086
%element_leave_4086 = load i8, i8* %element_addr_leave_4086
%compare_zero_leave_4086 = icmp ne i8 %element_leave_4086, 0
br i1 %compare_zero_leave_4086, label %loop_body_4086, label %post_loop_4086
post_loop_4086:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4086
; >ENTER_INC_PTR 571
%dataptr_571 = load i32, i32* %dataptr_addr
%inc_dataptr_571 = add i32 %dataptr_571, 8
store i32 %inc_dataptr_571, i32* %dataptr_addr
; <ENTER_INC_PTR 571
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4087
%dataptr_leave_4087 = load i32, i32* %dataptr_addr
%element_addr_leave_4087 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4087
%element_leave_4087 = load i8, i8* %element_addr_leave_4087
%compare_zero_leave_4087 = icmp ne i8 %element_leave_4087, 0
br i1 %compare_zero_leave_4087, label %loop_body_4087, label %post_loop_4087
post_loop_4087:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4087
; >ENTER_DEC_PTR 581
%dataptr_581 = load i32, i32* %dataptr_addr
%dec_dataptr_581 = sub i32 %dataptr_581, 10
store i32 %dec_dataptr_581, i32* %dataptr_addr
; <ENTER_DEC_PTR 581
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4089
%dataptr_enter_4089 = load i32, i32* %dataptr_addr
%element_addr_enter_4089 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4089
%element_enter_4089 = load i8, i8* %element_addr_enter_4089
%compare_zero_enter_4089 = icmp eq i8 %element_enter_4089, 0
br i1 %compare_zero_enter_4089, label %post_loop_4089, label %loop_body_4089
loop_body_4089:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4089
; >ENTER_INC_PTR 592
%dataptr_592 = load i32, i32* %dataptr_addr
%inc_dataptr_592 = add i32 %dataptr_592, 6
store i32 %inc_dataptr_592, i32* %dataptr_addr
; <ENTER_INC_PTR 592
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4088
%dataptr_enter_4088 = load i32, i32* %dataptr_addr
%element_addr_enter_4088 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4088
%element_enter_4088 = load i8, i8* %element_addr_enter_4088
%compare_zero_enter_4088 = icmp eq i8 %element_enter_4088, 0
br i1 %compare_zero_enter_4088, label %post_loop_4088, label %loop_body_4088
loop_body_4088:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4088
; >ENTER_DEC_DATA 599
%dataptr_599 = load i32, i32* %dataptr_addr
%element_addr_599 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_599
%element_599 = load i8, i8* %element_addr_599
%sub_element_599 = sub i8 %element_599, 1
store i8 %sub_element_599, i8* %element_addr_599
; <ENTER_DEC_DATA 599
; >ENTER_DEC_PTR 600
%dataptr_600 = load i32, i32* %dataptr_addr
%dec_dataptr_600 = sub i32 %dataptr_600, 4
store i32 %dec_dataptr_600, i32* %dataptr_addr
; <ENTER_DEC_PTR 600
; >ENTER_INC_DATA 604
%dataptr_604 = load i32, i32* %dataptr_addr
%element_addr_604 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_604
%element_604 = load i8, i8* %element_addr_604
%inc_element_604 = add i8 %element_604, 1
store i8 %inc_element_604, i8* %element_addr_604
; <ENTER_INC_DATA 604
; >ENTER_INC_PTR 605
%dataptr_605 = load i32, i32* %dataptr_addr
%inc_dataptr_605 = add i32 %dataptr_605, 4
store i32 %inc_dataptr_605, i32* %dataptr_addr
; <ENTER_INC_PTR 605
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4088
%dataptr_leave_4088 = load i32, i32* %dataptr_addr
%element_addr_leave_4088 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4088
%element_leave_4088 = load i8, i8* %element_addr_leave_4088
%compare_zero_leave_4088 = icmp ne i8 %element_leave_4088, 0
br i1 %compare_zero_leave_4088, label %loop_body_4088, label %post_loop_4088
post_loop_4088:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4088
; >ENTER_DEC_PTR 610
%dataptr_610 = load i32, i32* %dataptr_addr
%dec_dataptr_610 = sub i32 %dataptr_610, 16
store i32 %dec_dataptr_610, i32* %dataptr_addr
; <ENTER_DEC_PTR 610
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4089
%dataptr_leave_4089 = load i32, i32* %dataptr_addr
%element_addr_leave_4089 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4089
%element_leave_4089 = load i8, i8* %element_addr_leave_4089
%compare_zero_leave_4089 = icmp ne i8 %element_leave_4089, 0
br i1 %compare_zero_leave_4089, label %loop_body_4089, label %post_loop_4089
post_loop_4089:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4089
; >ENTER_INC_PTR 627
%dataptr_627 = load i32, i32* %dataptr_addr
%inc_dataptr_627 = add i32 %dataptr_627, 10
store i32 %inc_dataptr_627, i32* %dataptr_addr
; <ENTER_INC_PTR 627
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4091
%dataptr_enter_4091 = load i32, i32* %dataptr_addr
%element_addr_enter_4091 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4091
%element_enter_4091 = load i8, i8* %element_addr_enter_4091
%compare_zero_enter_4091 = icmp eq i8 %element_enter_4091, 0
br i1 %compare_zero_enter_4091, label %post_loop_4091, label %loop_body_4091
loop_body_4091:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4091
; >ENTER_INC_PTR 639
%dataptr_639 = load i32, i32* %dataptr_addr
%inc_dataptr_639 = add i32 %dataptr_639, 1
store i32 %inc_dataptr_639, i32* %dataptr_addr
; <ENTER_INC_PTR 639
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4090
%dataptr_enter_4090 = load i32, i32* %dataptr_addr
%element_addr_enter_4090 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4090
%element_enter_4090 = load i8, i8* %element_addr_enter_4090
%compare_zero_enter_4090 = icmp eq i8 %element_enter_4090, 0
br i1 %compare_zero_enter_4090, label %post_loop_4090, label %loop_body_4090
loop_body_4090:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4090
; >ENTER_DEC_DATA 641
%dataptr_641 = load i32, i32* %dataptr_addr
%element_addr_641 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_641
%element_641 = load i8, i8* %element_addr_641
%sub_element_641 = sub i8 %element_641, 1
store i8 %sub_element_641, i8* %element_addr_641
; <ENTER_DEC_DATA 641
; >ENTER_INC_PTR 642
%dataptr_642 = load i32, i32* %dataptr_addr
%inc_dataptr_642 = add i32 %dataptr_642, 3
store i32 %inc_dataptr_642, i32* %dataptr_addr
; <ENTER_INC_PTR 642
; >ENTER_INC_DATA 645
%dataptr_645 = load i32, i32* %dataptr_addr
%element_addr_645 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_645
%element_645 = load i8, i8* %element_addr_645
%inc_element_645 = add i8 %element_645, 1
store i8 %inc_element_645, i8* %element_addr_645
; <ENTER_INC_DATA 645
; >ENTER_INC_PTR 646
%dataptr_646 = load i32, i32* %dataptr_addr
%inc_dataptr_646 = add i32 %dataptr_646, 2
store i32 %inc_dataptr_646, i32* %dataptr_addr
; <ENTER_INC_PTR 646
; >ENTER_INC_DATA 648
%dataptr_648 = load i32, i32* %dataptr_addr
%element_addr_648 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_648
%element_648 = load i8, i8* %element_addr_648
%inc_element_648 = add i8 %element_648, 1
store i8 %inc_element_648, i8* %element_addr_648
; <ENTER_INC_DATA 648
; >ENTER_DEC_PTR 649
%dataptr_649 = load i32, i32* %dataptr_addr
%dec_dataptr_649 = sub i32 %dataptr_649, 5
store i32 %dec_dataptr_649, i32* %dataptr_addr
; <ENTER_DEC_PTR 649
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4090
%dataptr_leave_4090 = load i32, i32* %dataptr_addr
%element_addr_leave_4090 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4090
%element_leave_4090 = load i8, i8* %element_addr_leave_4090
%compare_zero_leave_4090 = icmp ne i8 %element_leave_4090, 0
br i1 %compare_zero_leave_4090, label %loop_body_4090, label %post_loop_4090
post_loop_4090:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4090
; >ENTER_INC_PTR 655
%dataptr_655 = load i32, i32* %dataptr_addr
%inc_dataptr_655 = add i32 %dataptr_655, 9
store i32 %inc_dataptr_655, i32* %dataptr_addr
; <ENTER_INC_PTR 655
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4091
%dataptr_leave_4091 = load i32, i32* %dataptr_addr
%element_addr_leave_4091 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4091
%element_leave_4091 = load i8, i8* %element_addr_leave_4091
%compare_zero_leave_4091 = icmp ne i8 %element_leave_4091, 0
br i1 %compare_zero_leave_4091, label %loop_body_4091, label %post_loop_4091
post_loop_4091:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4091
; >ENTER_DEC_PTR 666
%dataptr_666 = load i32, i32* %dataptr_addr
%dec_dataptr_666 = sub i32 %dataptr_666, 10
store i32 %dec_dataptr_666, i32* %dataptr_addr
; <ENTER_DEC_PTR 666
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4093
%dataptr_enter_4093 = load i32, i32* %dataptr_addr
%element_addr_enter_4093 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4093
%element_enter_4093 = load i8, i8* %element_addr_enter_4093
%compare_zero_enter_4093 = icmp eq i8 %element_enter_4093, 0
br i1 %compare_zero_enter_4093, label %post_loop_4093, label %loop_body_4093
loop_body_4093:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4093
; >ENTER_INC_PTR 677
%dataptr_677 = load i32, i32* %dataptr_addr
%inc_dataptr_677 = add i32 %dataptr_677, 6
store i32 %inc_dataptr_677, i32* %dataptr_addr
; <ENTER_INC_PTR 677
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4092
%dataptr_enter_4092 = load i32, i32* %dataptr_addr
%element_addr_enter_4092 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4092
%element_enter_4092 = load i8, i8* %element_addr_enter_4092
%compare_zero_enter_4092 = icmp eq i8 %element_enter_4092, 0
br i1 %compare_zero_enter_4092, label %post_loop_4092, label %loop_body_4092
loop_body_4092:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4092
; >ENTER_DEC_DATA 684
%dataptr_684 = load i32, i32* %dataptr_addr
%element_addr_684 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_684
%element_684 = load i8, i8* %element_addr_684
%sub_element_684 = sub i8 %element_684, 1
store i8 %sub_element_684, i8* %element_addr_684
; <ENTER_DEC_DATA 684
; >ENTER_DEC_PTR 685
%dataptr_685 = load i32, i32* %dataptr_addr
%dec_dataptr_685 = sub i32 %dataptr_685, 5
store i32 %dec_dataptr_685, i32* %dataptr_addr
; <ENTER_DEC_PTR 685
; >ENTER_INC_DATA 690
%dataptr_690 = load i32, i32* %dataptr_addr
%element_addr_690 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_690
%element_690 = load i8, i8* %element_addr_690
%inc_element_690 = add i8 %element_690, 1
store i8 %inc_element_690, i8* %element_addr_690
; <ENTER_INC_DATA 690
; >ENTER_INC_PTR 691
%dataptr_691 = load i32, i32* %dataptr_addr
%inc_dataptr_691 = add i32 %dataptr_691, 5
store i32 %inc_dataptr_691, i32* %dataptr_addr
; <ENTER_INC_PTR 691
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4092
%dataptr_leave_4092 = load i32, i32* %dataptr_addr
%element_addr_leave_4092 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4092
%element_leave_4092 = load i8, i8* %element_addr_leave_4092
%compare_zero_leave_4092 = icmp ne i8 %element_leave_4092, 0
br i1 %compare_zero_leave_4092, label %loop_body_4092, label %post_loop_4092
post_loop_4092:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4092
; >ENTER_DEC_PTR 697
%dataptr_697 = load i32, i32* %dataptr_addr
%dec_dataptr_697 = sub i32 %dataptr_697, 16
store i32 %dec_dataptr_697, i32* %dataptr_addr
; <ENTER_DEC_PTR 697
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4093
%dataptr_leave_4093 = load i32, i32* %dataptr_addr
%element_addr_leave_4093 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4093
%element_leave_4093 = load i8, i8* %element_addr_leave_4093
%compare_zero_leave_4093 = icmp ne i8 %element_leave_4093, 0
br i1 %compare_zero_leave_4093, label %loop_body_4093, label %post_loop_4093
post_loop_4093:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4093
; >ENTER_INC_PTR 714
%dataptr_714 = load i32, i32* %dataptr_addr
%inc_dataptr_714 = add i32 %dataptr_714, 10
store i32 %inc_dataptr_714, i32* %dataptr_addr
; <ENTER_INC_PTR 714
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4097
%dataptr_enter_4097 = load i32, i32* %dataptr_addr
%element_addr_enter_4097 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4097
%element_enter_4097 = load i8, i8* %element_addr_enter_4097
%compare_zero_enter_4097 = icmp eq i8 %element_enter_4097, 0
br i1 %compare_zero_enter_4097, label %post_loop_4097, label %loop_body_4097
loop_body_4097:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4097
; >ENTER_INC_PTR 726
%dataptr_726 = load i32, i32* %dataptr_addr
%inc_dataptr_726 = add i32 %dataptr_726, 3
store i32 %inc_dataptr_726, i32* %dataptr_addr
; <ENTER_INC_PTR 726
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4094
%dataptr_enter_4094 = load i32, i32* %dataptr_addr
%element_addr_enter_4094 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4094
%element_enter_4094 = load i8, i8* %element_addr_enter_4094
%compare_zero_enter_4094 = icmp eq i8 %element_enter_4094, 0
br i1 %compare_zero_enter_4094, label %post_loop_4094, label %loop_body_4094
loop_body_4094:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4094
; >ENTER_DEC_DATA 730
%dataptr_730 = load i32, i32* %dataptr_addr
%element_addr_730 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_730
%element_730 = load i8, i8* %element_addr_730
%sub_element_730 = sub i8 %element_730, 1
store i8 %sub_element_730, i8* %element_addr_730
; <ENTER_DEC_DATA 730
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4094
%dataptr_leave_4094 = load i32, i32* %dataptr_addr
%element_addr_leave_4094 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4094
%element_leave_4094 = load i8, i8* %element_addr_leave_4094
%compare_zero_leave_4094 = icmp ne i8 %element_leave_4094, 0
br i1 %compare_zero_leave_4094, label %loop_body_4094, label %post_loop_4094
post_loop_4094:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4094
; >ENTER_INC_PTR 732
%dataptr_732 = load i32, i32* %dataptr_addr
%inc_dataptr_732 = add i32 %dataptr_732, 3
store i32 %inc_dataptr_732, i32* %dataptr_addr
; <ENTER_INC_PTR 732
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4095
%dataptr_enter_4095 = load i32, i32* %dataptr_addr
%element_addr_enter_4095 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4095
%element_enter_4095 = load i8, i8* %element_addr_enter_4095
%compare_zero_enter_4095 = icmp eq i8 %element_enter_4095, 0
br i1 %compare_zero_enter_4095, label %post_loop_4095, label %loop_body_4095
loop_body_4095:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4095
; >ENTER_DEC_DATA 736
%dataptr_736 = load i32, i32* %dataptr_addr
%element_addr_736 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_736
%element_736 = load i8, i8* %element_addr_736
%sub_element_736 = sub i8 %element_736, 1
store i8 %sub_element_736, i8* %element_addr_736
; <ENTER_DEC_DATA 736
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4095
%dataptr_leave_4095 = load i32, i32* %dataptr_addr
%element_addr_leave_4095 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4095
%element_leave_4095 = load i8, i8* %element_addr_leave_4095
%compare_zero_leave_4095 = icmp ne i8 %element_leave_4095, 0
br i1 %compare_zero_leave_4095, label %loop_body_4095, label %post_loop_4095
post_loop_4095:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4095
; >ENTER_INC_PTR 738
%dataptr_738 = load i32, i32* %dataptr_addr
%inc_dataptr_738 = add i32 %dataptr_738, 1
store i32 %inc_dataptr_738, i32* %dataptr_addr
; <ENTER_INC_PTR 738
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4096
%dataptr_enter_4096 = load i32, i32* %dataptr_addr
%element_addr_enter_4096 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4096
%element_enter_4096 = load i8, i8* %element_addr_enter_4096
%compare_zero_enter_4096 = icmp eq i8 %element_enter_4096, 0
br i1 %compare_zero_enter_4096, label %post_loop_4096, label %loop_body_4096
loop_body_4096:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4096
; >ENTER_DEC_DATA 740
%dataptr_740 = load i32, i32* %dataptr_addr
%element_addr_740 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_740
%element_740 = load i8, i8* %element_addr_740
%sub_element_740 = sub i8 %element_740, 1
store i8 %sub_element_740, i8* %element_addr_740
; <ENTER_DEC_DATA 740
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4096
%dataptr_leave_4096 = load i32, i32* %dataptr_addr
%element_addr_leave_4096 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4096
%element_leave_4096 = load i8, i8* %element_addr_leave_4096
%compare_zero_leave_4096 = icmp ne i8 %element_leave_4096, 0
br i1 %compare_zero_leave_4096, label %loop_body_4096, label %post_loop_4096
post_loop_4096:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4096
; >ENTER_INC_PTR 742
%dataptr_742 = load i32, i32* %dataptr_addr
%inc_dataptr_742 = add i32 %dataptr_742, 3
store i32 %inc_dataptr_742, i32* %dataptr_addr
; <ENTER_INC_PTR 742
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4097
%dataptr_leave_4097 = load i32, i32* %dataptr_addr
%element_addr_leave_4097 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4097
%element_leave_4097 = load i8, i8* %element_addr_leave_4097
%compare_zero_leave_4097 = icmp ne i8 %element_leave_4097, 0
br i1 %compare_zero_leave_4097, label %loop_body_4097, label %post_loop_4097
post_loop_4097:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4097
; >ENTER_DEC_PTR 747
%dataptr_747 = load i32, i32* %dataptr_addr
%dec_dataptr_747 = sub i32 %dataptr_747, 10
store i32 %dec_dataptr_747, i32* %dataptr_addr
; <ENTER_DEC_PTR 747
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4098
%dataptr_enter_4098 = load i32, i32* %dataptr_addr
%element_addr_enter_4098 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4098
%element_enter_4098 = load i8, i8* %element_addr_enter_4098
%compare_zero_enter_4098 = icmp eq i8 %element_enter_4098, 0
br i1 %compare_zero_enter_4098, label %post_loop_4098, label %loop_body_4098
loop_body_4098:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4098
; >ENTER_DEC_PTR 758
%dataptr_758 = load i32, i32* %dataptr_addr
%dec_dataptr_758 = sub i32 %dataptr_758, 10
store i32 %dec_dataptr_758, i32* %dataptr_addr
; <ENTER_DEC_PTR 758
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4098
%dataptr_leave_4098 = load i32, i32* %dataptr_addr
%element_addr_leave_4098 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4098
%element_leave_4098 = load i8, i8* %element_addr_leave_4098
%compare_zero_leave_4098 = icmp ne i8 %element_leave_4098, 0
br i1 %compare_zero_leave_4098, label %loop_body_4098, label %post_loop_4098
post_loop_4098:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4098
; >ENTER_INC_PTR 770
%dataptr_770 = load i32, i32* %dataptr_addr
%inc_dataptr_770 = add i32 %dataptr_770, 9
store i32 %inc_dataptr_770, i32* %dataptr_addr
; <ENTER_INC_PTR 770
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4099
%dataptr_enter_4099 = load i32, i32* %dataptr_addr
%element_addr_enter_4099 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4099
%element_enter_4099 = load i8, i8* %element_addr_enter_4099
%compare_zero_enter_4099 = icmp eq i8 %element_enter_4099, 0
br i1 %compare_zero_enter_4099, label %post_loop_4099, label %loop_body_4099
loop_body_4099:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4099
; >ENTER_DEC_DATA 780
%dataptr_780 = load i32, i32* %dataptr_addr
%element_addr_780 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_780
%element_780 = load i8, i8* %element_addr_780
%sub_element_780 = sub i8 %element_780, 1
store i8 %sub_element_780, i8* %element_addr_780
; <ENTER_DEC_DATA 780
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4099
%dataptr_leave_4099 = load i32, i32* %dataptr_addr
%element_addr_leave_4099 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4099
%element_leave_4099 = load i8, i8* %element_addr_leave_4099
%compare_zero_leave_4099 = icmp ne i8 %element_leave_4099, 0
br i1 %compare_zero_leave_4099, label %loop_body_4099, label %post_loop_4099
post_loop_4099:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4099
; >ENTER_INC_PTR 782
%dataptr_782 = load i32, i32* %dataptr_addr
%inc_dataptr_782 = add i32 %dataptr_782, 7
store i32 %inc_dataptr_782, i32* %dataptr_addr
; <ENTER_INC_PTR 782
; >ENTER_INC_DATA 789
%dataptr_789 = load i32, i32* %dataptr_addr
%element_addr_789 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_789
%element_789 = load i8, i8* %element_addr_789
%inc_element_789 = add i8 %element_789, 1
store i8 %inc_element_789, i8* %element_addr_789
; <ENTER_INC_DATA 789
; >ENTER_DEC_PTR 790
%dataptr_790 = load i32, i32* %dataptr_addr
%dec_dataptr_790 = sub i32 %dataptr_790, 8
store i32 %dec_dataptr_790, i32* %dataptr_addr
; <ENTER_DEC_PTR 790
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4100
%dataptr_enter_4100 = load i32, i32* %dataptr_addr
%element_addr_enter_4100 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4100
%element_enter_4100 = load i8, i8* %element_addr_enter_4100
%compare_zero_enter_4100 = icmp eq i8 %element_enter_4100, 0
br i1 %compare_zero_enter_4100, label %post_loop_4100, label %loop_body_4100
loop_body_4100:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4100
; >ENTER_INC_DATA 799
%dataptr_799 = load i32, i32* %dataptr_addr
%element_addr_799 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_799
%element_799 = load i8, i8* %element_addr_799
%inc_element_799 = add i8 %element_799, 1
store i8 %inc_element_799, i8* %element_addr_799
; <ENTER_INC_DATA 799
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4100
%dataptr_leave_4100 = load i32, i32* %dataptr_addr
%element_addr_leave_4100 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4100
%element_leave_4100 = load i8, i8* %element_addr_leave_4100
%compare_zero_leave_4100 = icmp ne i8 %element_leave_4100, 0
br i1 %compare_zero_leave_4100, label %loop_body_4100, label %post_loop_4100
post_loop_4100:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4100
; >ENTER_INC_DATA 801
%dataptr_801 = load i32, i32* %dataptr_addr
%element_addr_801 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_801
%element_801 = load i8, i8* %element_addr_801
%inc_element_801 = add i8 %element_801, 1
store i8 %inc_element_801, i8* %element_addr_801
; <ENTER_INC_DATA 801
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4155
%dataptr_enter_4155 = load i32, i32* %dataptr_addr
%element_addr_enter_4155 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4155
%element_enter_4155 = load i8, i8* %element_addr_enter_4155
%compare_zero_enter_4155 = icmp eq i8 %element_enter_4155, 0
br i1 %compare_zero_enter_4155, label %post_loop_4155, label %loop_body_4155
loop_body_4155:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4155
; >ENTER_DEC_DATA 805
%dataptr_805 = load i32, i32* %dataptr_addr
%element_addr_805 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_805
%element_805 = load i8, i8* %element_addr_805
%sub_element_805 = sub i8 %element_805, 1
store i8 %sub_element_805, i8* %element_addr_805
; <ENTER_DEC_DATA 805
; >ENTER_INC_PTR 806
%dataptr_806 = load i32, i32* %dataptr_addr
%inc_dataptr_806 = add i32 %dataptr_806, 2
store i32 %inc_dataptr_806, i32* %dataptr_addr
; <ENTER_INC_PTR 806
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4102
%dataptr_enter_4102 = load i32, i32* %dataptr_addr
%element_addr_enter_4102 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4102
%element_enter_4102 = load i8, i8* %element_addr_enter_4102
%compare_zero_enter_4102 = icmp eq i8 %element_enter_4102, 0
br i1 %compare_zero_enter_4102, label %post_loop_4102, label %loop_body_4102
loop_body_4102:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4102
; >ENTER_INC_PTR 810
%dataptr_810 = load i32, i32* %dataptr_addr
%inc_dataptr_810 = add i32 %dataptr_810, 6
store i32 %inc_dataptr_810, i32* %dataptr_addr
; <ENTER_INC_PTR 810
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4101
%dataptr_enter_4101 = load i32, i32* %dataptr_addr
%element_addr_enter_4101 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4101
%element_enter_4101 = load i8, i8* %element_addr_enter_4101
%compare_zero_enter_4101 = icmp eq i8 %element_enter_4101, 0
br i1 %compare_zero_enter_4101, label %post_loop_4101, label %loop_body_4101
loop_body_4101:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4101
; >ENTER_DEC_DATA 817
%dataptr_817 = load i32, i32* %dataptr_addr
%element_addr_817 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_817
%element_817 = load i8, i8* %element_addr_817
%sub_element_817 = sub i8 %element_817, 1
store i8 %sub_element_817, i8* %element_addr_817
; <ENTER_DEC_DATA 817
; >ENTER_INC_PTR 818
%dataptr_818 = load i32, i32* %dataptr_addr
%inc_dataptr_818 = add i32 %dataptr_818, 1
store i32 %inc_dataptr_818, i32* %dataptr_addr
; <ENTER_INC_PTR 818
; >ENTER_INC_DATA 819
%dataptr_819 = load i32, i32* %dataptr_addr
%element_addr_819 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_819
%element_819 = load i8, i8* %element_addr_819
%inc_element_819 = add i8 %element_819, 2
store i8 %inc_element_819, i8* %element_addr_819
; <ENTER_INC_DATA 819
; >ENTER_DEC_PTR 821
%dataptr_821 = load i32, i32* %dataptr_addr
%dec_dataptr_821 = sub i32 %dataptr_821, 1
store i32 %dec_dataptr_821, i32* %dataptr_addr
; <ENTER_DEC_PTR 821
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4101
%dataptr_leave_4101 = load i32, i32* %dataptr_addr
%element_addr_leave_4101 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4101
%element_leave_4101 = load i8, i8* %element_addr_leave_4101
%compare_zero_leave_4101 = icmp ne i8 %element_leave_4101, 0
br i1 %compare_zero_leave_4101, label %loop_body_4101, label %post_loop_4101
post_loop_4101:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4101
; >ENTER_INC_PTR 823
%dataptr_823 = load i32, i32* %dataptr_addr
%inc_dataptr_823 = add i32 %dataptr_823, 4
store i32 %inc_dataptr_823, i32* %dataptr_addr
; <ENTER_INC_PTR 823
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4102
%dataptr_leave_4102 = load i32, i32* %dataptr_addr
%element_addr_leave_4102 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4102
%element_leave_4102 = load i8, i8* %element_addr_leave_4102
%compare_zero_leave_4102 = icmp ne i8 %element_leave_4102, 0
br i1 %compare_zero_leave_4102, label %loop_body_4102, label %post_loop_4102
post_loop_4102:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4102
; >ENTER_DEC_PTR 828
%dataptr_828 = load i32, i32* %dataptr_addr
%dec_dataptr_828 = sub i32 %dataptr_828, 10
store i32 %dec_dataptr_828, i32* %dataptr_addr
; <ENTER_DEC_PTR 828
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4106
%dataptr_enter_4106 = load i32, i32* %dataptr_addr
%element_addr_enter_4106 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4106
%element_enter_4106 = load i8, i8* %element_addr_enter_4106
%compare_zero_enter_4106 = icmp eq i8 %element_enter_4106, 0
br i1 %compare_zero_enter_4106, label %post_loop_4106, label %loop_body_4106
loop_body_4106:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4106
; >ENTER_INC_PTR 840
%dataptr_840 = load i32, i32* %dataptr_addr
%inc_dataptr_840 = add i32 %dataptr_840, 8
store i32 %inc_dataptr_840, i32* %dataptr_addr
; <ENTER_INC_PTR 840
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4103
%dataptr_enter_4103 = load i32, i32* %dataptr_addr
%element_addr_enter_4103 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4103
%element_enter_4103 = load i8, i8* %element_addr_enter_4103
%compare_zero_enter_4103 = icmp eq i8 %element_enter_4103, 0
br i1 %compare_zero_enter_4103, label %post_loop_4103, label %loop_body_4103
loop_body_4103:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4103
; >ENTER_DEC_DATA 849
%dataptr_849 = load i32, i32* %dataptr_addr
%element_addr_849 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_849
%element_849 = load i8, i8* %element_addr_849
%sub_element_849 = sub i8 %element_849, 1
store i8 %sub_element_849, i8* %element_addr_849
; <ENTER_DEC_DATA 849
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4103
%dataptr_leave_4103 = load i32, i32* %dataptr_addr
%element_addr_leave_4103 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4103
%element_leave_4103 = load i8, i8* %element_addr_leave_4103
%compare_zero_leave_4103 = icmp ne i8 %element_leave_4103, 0
br i1 %compare_zero_leave_4103, label %loop_body_4103, label %post_loop_4103
post_loop_4103:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4103
; >ENTER_INC_PTR 851
%dataptr_851 = load i32, i32* %dataptr_addr
%inc_dataptr_851 = add i32 %dataptr_851, 1
store i32 %inc_dataptr_851, i32* %dataptr_addr
; <ENTER_INC_PTR 851
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4104
%dataptr_enter_4104 = load i32, i32* %dataptr_addr
%element_addr_enter_4104 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4104
%element_enter_4104 = load i8, i8* %element_addr_enter_4104
%compare_zero_enter_4104 = icmp eq i8 %element_enter_4104, 0
br i1 %compare_zero_enter_4104, label %post_loop_4104, label %loop_body_4104
loop_body_4104:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4104
; >ENTER_DEC_DATA 853
%dataptr_853 = load i32, i32* %dataptr_addr
%element_addr_853 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_853
%element_853 = load i8, i8* %element_addr_853
%sub_element_853 = sub i8 %element_853, 1
store i8 %sub_element_853, i8* %element_addr_853
; <ENTER_DEC_DATA 853
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4104
%dataptr_leave_4104 = load i32, i32* %dataptr_addr
%element_addr_leave_4104 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4104
%element_leave_4104 = load i8, i8* %element_addr_leave_4104
%compare_zero_leave_4104 = icmp ne i8 %element_leave_4104, 0
br i1 %compare_zero_leave_4104, label %loop_body_4104, label %post_loop_4104
post_loop_4104:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4104
; >ENTER_DEC_PTR 856
%dataptr_856 = load i32, i32* %dataptr_addr
%dec_dataptr_856 = sub i32 %dataptr_856, 4
store i32 %dec_dataptr_856, i32* %dataptr_addr
; <ENTER_DEC_PTR 856
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4105
%dataptr_enter_4105 = load i32, i32* %dataptr_addr
%element_addr_enter_4105 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4105
%element_enter_4105 = load i8, i8* %element_addr_enter_4105
%compare_zero_enter_4105 = icmp eq i8 %element_enter_4105, 0
br i1 %compare_zero_enter_4105, label %post_loop_4105, label %loop_body_4105
loop_body_4105:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4105
; >ENTER_DEC_DATA 861
%dataptr_861 = load i32, i32* %dataptr_addr
%element_addr_861 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_861
%element_861 = load i8, i8* %element_addr_861
%sub_element_861 = sub i8 %element_861, 1
store i8 %sub_element_861, i8* %element_addr_861
; <ENTER_DEC_DATA 861
; >ENTER_INC_PTR 862
%dataptr_862 = load i32, i32* %dataptr_addr
%inc_dataptr_862 = add i32 %dataptr_862, 3
store i32 %inc_dataptr_862, i32* %dataptr_addr
; <ENTER_INC_PTR 862
; >ENTER_INC_DATA 865
%dataptr_865 = load i32, i32* %dataptr_addr
%element_addr_865 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_865
%element_865 = load i8, i8* %element_addr_865
%inc_element_865 = add i8 %element_865, 2
store i8 %inc_element_865, i8* %element_addr_865
; <ENTER_INC_DATA 865
; >ENTER_DEC_PTR 867
%dataptr_867 = load i32, i32* %dataptr_addr
%dec_dataptr_867 = sub i32 %dataptr_867, 3
store i32 %dec_dataptr_867, i32* %dataptr_addr
; <ENTER_DEC_PTR 867
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4105
%dataptr_leave_4105 = load i32, i32* %dataptr_addr
%element_addr_leave_4105 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4105
%element_leave_4105 = load i8, i8* %element_addr_leave_4105
%compare_zero_leave_4105 = icmp ne i8 %element_leave_4105, 0
br i1 %compare_zero_leave_4105, label %loop_body_4105, label %post_loop_4105
post_loop_4105:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4105
; >ENTER_DEC_PTR 871
%dataptr_871 = load i32, i32* %dataptr_addr
%dec_dataptr_871 = sub i32 %dataptr_871, 15
store i32 %dec_dataptr_871, i32* %dataptr_addr
; <ENTER_DEC_PTR 871
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4106
%dataptr_leave_4106 = load i32, i32* %dataptr_addr
%element_addr_leave_4106 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4106
%element_leave_4106 = load i8, i8* %element_addr_leave_4106
%compare_zero_leave_4106 = icmp ne i8 %element_leave_4106, 0
br i1 %compare_zero_leave_4106, label %loop_body_4106, label %post_loop_4106
post_loop_4106:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4106
; >ENTER_INC_PTR 887
%dataptr_887 = load i32, i32* %dataptr_addr
%inc_dataptr_887 = add i32 %dataptr_887, 10
store i32 %inc_dataptr_887, i32* %dataptr_addr
; <ENTER_INC_PTR 887
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4118
%dataptr_enter_4118 = load i32, i32* %dataptr_addr
%element_addr_enter_4118 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4118
%element_enter_4118 = load i8, i8* %element_addr_enter_4118
%compare_zero_enter_4118 = icmp eq i8 %element_enter_4118, 0
br i1 %compare_zero_enter_4118, label %post_loop_4118, label %loop_body_4118
loop_body_4118:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4118
; >ENTER_INC_PTR 899
%dataptr_899 = load i32, i32* %dataptr_addr
%inc_dataptr_899 = add i32 %dataptr_899, 8
store i32 %inc_dataptr_899, i32* %dataptr_addr
; <ENTER_INC_PTR 899
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4117
%dataptr_enter_4117 = load i32, i32* %dataptr_addr
%element_addr_enter_4117 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4117
%element_enter_4117 = load i8, i8* %element_addr_enter_4117
%compare_zero_enter_4117 = icmp eq i8 %element_enter_4117, 0
br i1 %compare_zero_enter_4117, label %post_loop_4117, label %loop_body_4117
loop_body_4117:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4117
; >ENTER_DEC_DATA 908
%dataptr_908 = load i32, i32* %dataptr_addr
%element_addr_908 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_908
%element_908 = load i8, i8* %element_addr_908
%sub_element_908 = sub i8 %element_908, 1
store i8 %sub_element_908, i8* %element_addr_908
; <ENTER_DEC_DATA 908
; >ENTER_INC_PTR 909
%dataptr_909 = load i32, i32* %dataptr_addr
%inc_dataptr_909 = add i32 %dataptr_909, 1
store i32 %inc_dataptr_909, i32* %dataptr_addr
; <ENTER_INC_PTR 909
; >ENTER_INC_DATA 910
%dataptr_910 = load i32, i32* %dataptr_addr
%element_addr_910 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_910
%element_910 = load i8, i8* %element_addr_910
%inc_element_910 = add i8 %element_910, 1
store i8 %inc_element_910, i8* %element_addr_910
; <ENTER_INC_DATA 910
; >ENTER_DEC_PTR 911
%dataptr_911 = load i32, i32* %dataptr_addr
%dec_dataptr_911 = sub i32 %dataptr_911, 1
store i32 %dec_dataptr_911, i32* %dataptr_addr
; <ENTER_DEC_PTR 911
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4116
%dataptr_enter_4116 = load i32, i32* %dataptr_addr
%element_addr_enter_4116 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4116
%element_enter_4116 = load i8, i8* %element_addr_enter_4116
%compare_zero_enter_4116 = icmp eq i8 %element_enter_4116, 0
br i1 %compare_zero_enter_4116, label %post_loop_4116, label %loop_body_4116
loop_body_4116:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4116
; >ENTER_DEC_DATA 913
%dataptr_913 = load i32, i32* %dataptr_addr
%element_addr_913 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_913
%element_913 = load i8, i8* %element_addr_913
%sub_element_913 = sub i8 %element_913, 1
store i8 %sub_element_913, i8* %element_addr_913
; <ENTER_DEC_DATA 913
; >ENTER_INC_PTR 914
%dataptr_914 = load i32, i32* %dataptr_addr
%inc_dataptr_914 = add i32 %dataptr_914, 1
store i32 %inc_dataptr_914, i32* %dataptr_addr
; <ENTER_INC_PTR 914
; >ENTER_INC_DATA 915
%dataptr_915 = load i32, i32* %dataptr_addr
%element_addr_915 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_915
%element_915 = load i8, i8* %element_addr_915
%inc_element_915 = add i8 %element_915, 1
store i8 %inc_element_915, i8* %element_addr_915
; <ENTER_INC_DATA 915
; >ENTER_DEC_PTR 916
%dataptr_916 = load i32, i32* %dataptr_addr
%dec_dataptr_916 = sub i32 %dataptr_916, 1
store i32 %dec_dataptr_916, i32* %dataptr_addr
; <ENTER_DEC_PTR 916
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4115
%dataptr_enter_4115 = load i32, i32* %dataptr_addr
%element_addr_enter_4115 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4115
%element_enter_4115 = load i8, i8* %element_addr_enter_4115
%compare_zero_enter_4115 = icmp eq i8 %element_enter_4115, 0
br i1 %compare_zero_enter_4115, label %post_loop_4115, label %loop_body_4115
loop_body_4115:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4115
; >ENTER_DEC_DATA 918
%dataptr_918 = load i32, i32* %dataptr_addr
%element_addr_918 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_918
%element_918 = load i8, i8* %element_addr_918
%sub_element_918 = sub i8 %element_918, 1
store i8 %sub_element_918, i8* %element_addr_918
; <ENTER_DEC_DATA 918
; >ENTER_INC_PTR 919
%dataptr_919 = load i32, i32* %dataptr_addr
%inc_dataptr_919 = add i32 %dataptr_919, 1
store i32 %inc_dataptr_919, i32* %dataptr_addr
; <ENTER_INC_PTR 919
; >ENTER_INC_DATA 920
%dataptr_920 = load i32, i32* %dataptr_addr
%element_addr_920 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_920
%element_920 = load i8, i8* %element_addr_920
%inc_element_920 = add i8 %element_920, 1
store i8 %inc_element_920, i8* %element_addr_920
; <ENTER_INC_DATA 920
; >ENTER_DEC_PTR 921
%dataptr_921 = load i32, i32* %dataptr_addr
%dec_dataptr_921 = sub i32 %dataptr_921, 1
store i32 %dec_dataptr_921, i32* %dataptr_addr
; <ENTER_DEC_PTR 921
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4114
%dataptr_enter_4114 = load i32, i32* %dataptr_addr
%element_addr_enter_4114 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4114
%element_enter_4114 = load i8, i8* %element_addr_enter_4114
%compare_zero_enter_4114 = icmp eq i8 %element_enter_4114, 0
br i1 %compare_zero_enter_4114, label %post_loop_4114, label %loop_body_4114
loop_body_4114:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4114
; >ENTER_DEC_DATA 923
%dataptr_923 = load i32, i32* %dataptr_addr
%element_addr_923 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_923
%element_923 = load i8, i8* %element_addr_923
%sub_element_923 = sub i8 %element_923, 1
store i8 %sub_element_923, i8* %element_addr_923
; <ENTER_DEC_DATA 923
; >ENTER_INC_PTR 924
%dataptr_924 = load i32, i32* %dataptr_addr
%inc_dataptr_924 = add i32 %dataptr_924, 1
store i32 %inc_dataptr_924, i32* %dataptr_addr
; <ENTER_INC_PTR 924
; >ENTER_INC_DATA 925
%dataptr_925 = load i32, i32* %dataptr_addr
%element_addr_925 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_925
%element_925 = load i8, i8* %element_addr_925
%inc_element_925 = add i8 %element_925, 1
store i8 %inc_element_925, i8* %element_addr_925
; <ENTER_INC_DATA 925
; >ENTER_DEC_PTR 926
%dataptr_926 = load i32, i32* %dataptr_addr
%dec_dataptr_926 = sub i32 %dataptr_926, 1
store i32 %dec_dataptr_926, i32* %dataptr_addr
; <ENTER_DEC_PTR 926
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4113
%dataptr_enter_4113 = load i32, i32* %dataptr_addr
%element_addr_enter_4113 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4113
%element_enter_4113 = load i8, i8* %element_addr_enter_4113
%compare_zero_enter_4113 = icmp eq i8 %element_enter_4113, 0
br i1 %compare_zero_enter_4113, label %post_loop_4113, label %loop_body_4113
loop_body_4113:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4113
; >ENTER_DEC_DATA 928
%dataptr_928 = load i32, i32* %dataptr_addr
%element_addr_928 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_928
%element_928 = load i8, i8* %element_addr_928
%sub_element_928 = sub i8 %element_928, 1
store i8 %sub_element_928, i8* %element_addr_928
; <ENTER_DEC_DATA 928
; >ENTER_INC_PTR 929
%dataptr_929 = load i32, i32* %dataptr_addr
%inc_dataptr_929 = add i32 %dataptr_929, 1
store i32 %inc_dataptr_929, i32* %dataptr_addr
; <ENTER_INC_PTR 929
; >ENTER_INC_DATA 930
%dataptr_930 = load i32, i32* %dataptr_addr
%element_addr_930 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_930
%element_930 = load i8, i8* %element_addr_930
%inc_element_930 = add i8 %element_930, 1
store i8 %inc_element_930, i8* %element_addr_930
; <ENTER_INC_DATA 930
; >ENTER_DEC_PTR 931
%dataptr_931 = load i32, i32* %dataptr_addr
%dec_dataptr_931 = sub i32 %dataptr_931, 1
store i32 %dec_dataptr_931, i32* %dataptr_addr
; <ENTER_DEC_PTR 931
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4112
%dataptr_enter_4112 = load i32, i32* %dataptr_addr
%element_addr_enter_4112 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4112
%element_enter_4112 = load i8, i8* %element_addr_enter_4112
%compare_zero_enter_4112 = icmp eq i8 %element_enter_4112, 0
br i1 %compare_zero_enter_4112, label %post_loop_4112, label %loop_body_4112
loop_body_4112:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4112
; >ENTER_DEC_DATA 933
%dataptr_933 = load i32, i32* %dataptr_addr
%element_addr_933 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_933
%element_933 = load i8, i8* %element_addr_933
%sub_element_933 = sub i8 %element_933, 1
store i8 %sub_element_933, i8* %element_addr_933
; <ENTER_DEC_DATA 933
; >ENTER_INC_PTR 934
%dataptr_934 = load i32, i32* %dataptr_addr
%inc_dataptr_934 = add i32 %dataptr_934, 1
store i32 %inc_dataptr_934, i32* %dataptr_addr
; <ENTER_INC_PTR 934
; >ENTER_INC_DATA 935
%dataptr_935 = load i32, i32* %dataptr_addr
%element_addr_935 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_935
%element_935 = load i8, i8* %element_addr_935
%inc_element_935 = add i8 %element_935, 1
store i8 %inc_element_935, i8* %element_addr_935
; <ENTER_INC_DATA 935
; >ENTER_DEC_PTR 936
%dataptr_936 = load i32, i32* %dataptr_addr
%dec_dataptr_936 = sub i32 %dataptr_936, 1
store i32 %dec_dataptr_936, i32* %dataptr_addr
; <ENTER_DEC_PTR 936
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4111
%dataptr_enter_4111 = load i32, i32* %dataptr_addr
%element_addr_enter_4111 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4111
%element_enter_4111 = load i8, i8* %element_addr_enter_4111
%compare_zero_enter_4111 = icmp eq i8 %element_enter_4111, 0
br i1 %compare_zero_enter_4111, label %post_loop_4111, label %loop_body_4111
loop_body_4111:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4111
; >ENTER_DEC_DATA 938
%dataptr_938 = load i32, i32* %dataptr_addr
%element_addr_938 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_938
%element_938 = load i8, i8* %element_addr_938
%sub_element_938 = sub i8 %element_938, 1
store i8 %sub_element_938, i8* %element_addr_938
; <ENTER_DEC_DATA 938
; >ENTER_INC_PTR 939
%dataptr_939 = load i32, i32* %dataptr_addr
%inc_dataptr_939 = add i32 %dataptr_939, 1
store i32 %inc_dataptr_939, i32* %dataptr_addr
; <ENTER_INC_PTR 939
; >ENTER_INC_DATA 940
%dataptr_940 = load i32, i32* %dataptr_addr
%element_addr_940 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_940
%element_940 = load i8, i8* %element_addr_940
%inc_element_940 = add i8 %element_940, 1
store i8 %inc_element_940, i8* %element_addr_940
; <ENTER_INC_DATA 940
; >ENTER_DEC_PTR 941
%dataptr_941 = load i32, i32* %dataptr_addr
%dec_dataptr_941 = sub i32 %dataptr_941, 1
store i32 %dec_dataptr_941, i32* %dataptr_addr
; <ENTER_DEC_PTR 941
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4110
%dataptr_enter_4110 = load i32, i32* %dataptr_addr
%element_addr_enter_4110 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4110
%element_enter_4110 = load i8, i8* %element_addr_enter_4110
%compare_zero_enter_4110 = icmp eq i8 %element_enter_4110, 0
br i1 %compare_zero_enter_4110, label %post_loop_4110, label %loop_body_4110
loop_body_4110:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4110
; >ENTER_DEC_DATA 943
%dataptr_943 = load i32, i32* %dataptr_addr
%element_addr_943 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_943
%element_943 = load i8, i8* %element_addr_943
%sub_element_943 = sub i8 %element_943, 1
store i8 %sub_element_943, i8* %element_addr_943
; <ENTER_DEC_DATA 943
; >ENTER_INC_PTR 944
%dataptr_944 = load i32, i32* %dataptr_addr
%inc_dataptr_944 = add i32 %dataptr_944, 1
store i32 %inc_dataptr_944, i32* %dataptr_addr
; <ENTER_INC_PTR 944
; >ENTER_INC_DATA 945
%dataptr_945 = load i32, i32* %dataptr_addr
%element_addr_945 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_945
%element_945 = load i8, i8* %element_addr_945
%inc_element_945 = add i8 %element_945, 1
store i8 %inc_element_945, i8* %element_addr_945
; <ENTER_INC_DATA 945
; >ENTER_DEC_PTR 946
%dataptr_946 = load i32, i32* %dataptr_addr
%dec_dataptr_946 = sub i32 %dataptr_946, 1
store i32 %dec_dataptr_946, i32* %dataptr_addr
; <ENTER_DEC_PTR 946
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4109
%dataptr_enter_4109 = load i32, i32* %dataptr_addr
%element_addr_enter_4109 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4109
%element_enter_4109 = load i8, i8* %element_addr_enter_4109
%compare_zero_enter_4109 = icmp eq i8 %element_enter_4109, 0
br i1 %compare_zero_enter_4109, label %post_loop_4109, label %loop_body_4109
loop_body_4109:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4109
; >ENTER_DEC_DATA 948
%dataptr_948 = load i32, i32* %dataptr_addr
%element_addr_948 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_948
%element_948 = load i8, i8* %element_addr_948
%sub_element_948 = sub i8 %element_948, 1
store i8 %sub_element_948, i8* %element_addr_948
; <ENTER_DEC_DATA 948
; >ENTER_INC_PTR 949
%dataptr_949 = load i32, i32* %dataptr_addr
%inc_dataptr_949 = add i32 %dataptr_949, 1
store i32 %inc_dataptr_949, i32* %dataptr_addr
; <ENTER_INC_PTR 949
; >ENTER_INC_DATA 950
%dataptr_950 = load i32, i32* %dataptr_addr
%element_addr_950 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_950
%element_950 = load i8, i8* %element_addr_950
%inc_element_950 = add i8 %element_950, 1
store i8 %inc_element_950, i8* %element_addr_950
; <ENTER_INC_DATA 950
; >ENTER_DEC_PTR 951
%dataptr_951 = load i32, i32* %dataptr_addr
%dec_dataptr_951 = sub i32 %dataptr_951, 1
store i32 %dec_dataptr_951, i32* %dataptr_addr
; <ENTER_DEC_PTR 951
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4108
%dataptr_enter_4108 = load i32, i32* %dataptr_addr
%element_addr_enter_4108 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4108
%element_enter_4108 = load i8, i8* %element_addr_enter_4108
%compare_zero_enter_4108 = icmp eq i8 %element_enter_4108, 0
br i1 %compare_zero_enter_4108, label %post_loop_4108, label %loop_body_4108
loop_body_4108:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4108
; >ENTER_DEC_DATA 954
%dataptr_954 = load i32, i32* %dataptr_addr
%element_addr_954 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_954
%element_954 = load i8, i8* %element_addr_954
%sub_element_954 = sub i8 %element_954, 1
store i8 %sub_element_954, i8* %element_addr_954
; <ENTER_DEC_DATA 954
; >ENTER_INC_PTR 955
%dataptr_955 = load i32, i32* %dataptr_addr
%inc_dataptr_955 = add i32 %dataptr_955, 1
store i32 %inc_dataptr_955, i32* %dataptr_addr
; <ENTER_INC_PTR 955
; >ENTER_DEC_DATA 956
%dataptr_956 = load i32, i32* %dataptr_addr
%element_addr_956 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_956
%element_956 = load i8, i8* %element_addr_956
%sub_element_956 = sub i8 %element_956, 9
store i8 %sub_element_956, i8* %element_addr_956
; <ENTER_DEC_DATA 956
; >ENTER_INC_PTR 965
%dataptr_965 = load i32, i32* %dataptr_addr
%inc_dataptr_965 = add i32 %dataptr_965, 9
store i32 %inc_dataptr_965, i32* %dataptr_addr
; <ENTER_INC_PTR 965
; >ENTER_INC_DATA 974
%dataptr_974 = load i32, i32* %dataptr_addr
%element_addr_974 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_974
%element_974 = load i8, i8* %element_addr_974
%inc_element_974 = add i8 %element_974, 1
store i8 %inc_element_974, i8* %element_addr_974
; <ENTER_INC_DATA 974
; >ENTER_DEC_PTR 975
%dataptr_975 = load i32, i32* %dataptr_addr
%dec_dataptr_975 = sub i32 %dataptr_975, 10
store i32 %dec_dataptr_975, i32* %dataptr_addr
; <ENTER_DEC_PTR 975
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4107
%dataptr_enter_4107 = load i32, i32* %dataptr_addr
%element_addr_enter_4107 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4107
%element_enter_4107 = load i8, i8* %element_addr_enter_4107
%compare_zero_enter_4107 = icmp eq i8 %element_enter_4107, 0
br i1 %compare_zero_enter_4107, label %post_loop_4107, label %loop_body_4107
loop_body_4107:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4107
; >ENTER_DEC_DATA 986
%dataptr_986 = load i32, i32* %dataptr_addr
%element_addr_986 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_986
%element_986 = load i8, i8* %element_addr_986
%sub_element_986 = sub i8 %element_986, 1
store i8 %sub_element_986, i8* %element_addr_986
; <ENTER_DEC_DATA 986
; >ENTER_INC_PTR 987
%dataptr_987 = load i32, i32* %dataptr_addr
%inc_dataptr_987 = add i32 %dataptr_987, 1
store i32 %inc_dataptr_987, i32* %dataptr_addr
; <ENTER_INC_PTR 987
; >ENTER_INC_DATA 988
%dataptr_988 = load i32, i32* %dataptr_addr
%element_addr_988 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_988
%element_988 = load i8, i8* %element_addr_988
%inc_element_988 = add i8 %element_988, 1
store i8 %inc_element_988, i8* %element_addr_988
; <ENTER_INC_DATA 988
; >ENTER_DEC_PTR 989
%dataptr_989 = load i32, i32* %dataptr_addr
%dec_dataptr_989 = sub i32 %dataptr_989, 1
store i32 %dec_dataptr_989, i32* %dataptr_addr
; <ENTER_DEC_PTR 989
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4107
%dataptr_leave_4107 = load i32, i32* %dataptr_addr
%element_addr_leave_4107 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4107
%element_leave_4107 = load i8, i8* %element_addr_leave_4107
%compare_zero_leave_4107 = icmp ne i8 %element_leave_4107, 0
br i1 %compare_zero_leave_4107, label %loop_body_4107, label %post_loop_4107
post_loop_4107:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4107
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4108
%dataptr_leave_4108 = load i32, i32* %dataptr_addr
%element_addr_leave_4108 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4108
%element_leave_4108 = load i8, i8* %element_addr_leave_4108
%compare_zero_leave_4108 = icmp ne i8 %element_leave_4108, 0
br i1 %compare_zero_leave_4108, label %loop_body_4108, label %post_loop_4108
post_loop_4108:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4108
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4109
%dataptr_leave_4109 = load i32, i32* %dataptr_addr
%element_addr_leave_4109 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4109
%element_leave_4109 = load i8, i8* %element_addr_leave_4109
%compare_zero_leave_4109 = icmp ne i8 %element_leave_4109, 0
br i1 %compare_zero_leave_4109, label %loop_body_4109, label %post_loop_4109
post_loop_4109:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4109
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4110
%dataptr_leave_4110 = load i32, i32* %dataptr_addr
%element_addr_leave_4110 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4110
%element_leave_4110 = load i8, i8* %element_addr_leave_4110
%compare_zero_leave_4110 = icmp ne i8 %element_leave_4110, 0
br i1 %compare_zero_leave_4110, label %loop_body_4110, label %post_loop_4110
post_loop_4110:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4110
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4111
%dataptr_leave_4111 = load i32, i32* %dataptr_addr
%element_addr_leave_4111 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4111
%element_leave_4111 = load i8, i8* %element_addr_leave_4111
%compare_zero_leave_4111 = icmp ne i8 %element_leave_4111, 0
br i1 %compare_zero_leave_4111, label %loop_body_4111, label %post_loop_4111
post_loop_4111:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4111
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4112
%dataptr_leave_4112 = load i32, i32* %dataptr_addr
%element_addr_leave_4112 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4112
%element_leave_4112 = load i8, i8* %element_addr_leave_4112
%compare_zero_leave_4112 = icmp ne i8 %element_leave_4112, 0
br i1 %compare_zero_leave_4112, label %loop_body_4112, label %post_loop_4112
post_loop_4112:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4112
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4113
%dataptr_leave_4113 = load i32, i32* %dataptr_addr
%element_addr_leave_4113 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4113
%element_leave_4113 = load i8, i8* %element_addr_leave_4113
%compare_zero_leave_4113 = icmp ne i8 %element_leave_4113, 0
br i1 %compare_zero_leave_4113, label %loop_body_4113, label %post_loop_4113
post_loop_4113:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4113
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4114
%dataptr_leave_4114 = load i32, i32* %dataptr_addr
%element_addr_leave_4114 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4114
%element_leave_4114 = load i8, i8* %element_addr_leave_4114
%compare_zero_leave_4114 = icmp ne i8 %element_leave_4114, 0
br i1 %compare_zero_leave_4114, label %loop_body_4114, label %post_loop_4114
post_loop_4114:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4114
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4115
%dataptr_leave_4115 = load i32, i32* %dataptr_addr
%element_addr_leave_4115 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4115
%element_leave_4115 = load i8, i8* %element_addr_leave_4115
%compare_zero_leave_4115 = icmp ne i8 %element_leave_4115, 0
br i1 %compare_zero_leave_4115, label %loop_body_4115, label %post_loop_4115
post_loop_4115:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4115
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4116
%dataptr_leave_4116 = load i32, i32* %dataptr_addr
%element_addr_leave_4116 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4116
%element_leave_4116 = load i8, i8* %element_addr_leave_4116
%compare_zero_leave_4116 = icmp ne i8 %element_leave_4116, 0
br i1 %compare_zero_leave_4116, label %loop_body_4116, label %post_loop_4116
post_loop_4116:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4116
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4117
%dataptr_leave_4117 = load i32, i32* %dataptr_addr
%element_addr_leave_4117 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4117
%element_leave_4117 = load i8, i8* %element_addr_leave_4117
%compare_zero_leave_4117 = icmp ne i8 %element_leave_4117, 0
br i1 %compare_zero_leave_4117, label %loop_body_4117, label %post_loop_4117
post_loop_4117:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4117
; >ENTER_INC_PTR 1001
%dataptr_1001 = load i32, i32* %dataptr_addr
%inc_dataptr_1001 = add i32 %dataptr_1001, 2
store i32 %inc_dataptr_1001, i32* %dataptr_addr
; <ENTER_INC_PTR 1001
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4118
%dataptr_leave_4118 = load i32, i32* %dataptr_addr
%element_addr_leave_4118 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4118
%element_leave_4118 = load i8, i8* %element_addr_leave_4118
%compare_zero_leave_4118 = icmp ne i8 %element_leave_4118, 0
br i1 %compare_zero_leave_4118, label %loop_body_4118, label %post_loop_4118
post_loop_4118:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4118
; >ENTER_DEC_PTR 1005
%dataptr_1005 = load i32, i32* %dataptr_addr
%dec_dataptr_1005 = sub i32 %dataptr_1005, 10
store i32 %dec_dataptr_1005, i32* %dataptr_addr
; <ENTER_DEC_PTR 1005
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4120
%dataptr_enter_4120 = load i32, i32* %dataptr_addr
%element_addr_enter_4120 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4120
%element_enter_4120 = load i8, i8* %element_addr_enter_4120
%compare_zero_enter_4120 = icmp eq i8 %element_enter_4120, 0
br i1 %compare_zero_enter_4120, label %post_loop_4120, label %loop_body_4120
loop_body_4120:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4120
; >ENTER_INC_PTR 1016
%dataptr_1016 = load i32, i32* %dataptr_addr
%inc_dataptr_1016 = add i32 %dataptr_1016, 9
store i32 %inc_dataptr_1016, i32* %dataptr_addr
; <ENTER_INC_PTR 1016
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4119
%dataptr_enter_4119 = load i32, i32* %dataptr_addr
%element_addr_enter_4119 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4119
%element_enter_4119 = load i8, i8* %element_addr_enter_4119
%compare_zero_enter_4119 = icmp eq i8 %element_enter_4119, 0
br i1 %compare_zero_enter_4119, label %post_loop_4119, label %loop_body_4119
loop_body_4119:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4119
; >ENTER_DEC_DATA 1026
%dataptr_1026 = load i32, i32* %dataptr_addr
%element_addr_1026 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1026
%element_1026 = load i8, i8* %element_addr_1026
%sub_element_1026 = sub i8 %element_1026, 1
store i8 %sub_element_1026, i8* %element_addr_1026
; <ENTER_DEC_DATA 1026
; >ENTER_DEC_PTR 1027
%dataptr_1027 = load i32, i32* %dataptr_addr
%dec_dataptr_1027 = sub i32 %dataptr_1027, 1
store i32 %dec_dataptr_1027, i32* %dataptr_addr
; <ENTER_DEC_PTR 1027
; >ENTER_INC_DATA 1028
%dataptr_1028 = load i32, i32* %dataptr_addr
%element_addr_1028 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1028
%element_1028 = load i8, i8* %element_addr_1028
%inc_element_1028 = add i8 %element_1028, 1
store i8 %inc_element_1028, i8* %element_addr_1028
; <ENTER_INC_DATA 1028
; >ENTER_DEC_PTR 1029
%dataptr_1029 = load i32, i32* %dataptr_addr
%dec_dataptr_1029 = sub i32 %dataptr_1029, 3
store i32 %dec_dataptr_1029, i32* %dataptr_addr
; <ENTER_DEC_PTR 1029
; >ENTER_INC_DATA 1032
%dataptr_1032 = load i32, i32* %dataptr_addr
%element_addr_1032 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1032
%element_1032 = load i8, i8* %element_addr_1032
%inc_element_1032 = add i8 %element_1032, 1
store i8 %inc_element_1032, i8* %element_addr_1032
; <ENTER_INC_DATA 1032
; >ENTER_INC_PTR 1033
%dataptr_1033 = load i32, i32* %dataptr_addr
%inc_dataptr_1033 = add i32 %dataptr_1033, 4
store i32 %inc_dataptr_1033, i32* %dataptr_addr
; <ENTER_INC_PTR 1033
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4119
%dataptr_leave_4119 = load i32, i32* %dataptr_addr
%element_addr_leave_4119 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4119
%element_leave_4119 = load i8, i8* %element_addr_leave_4119
%compare_zero_leave_4119 = icmp ne i8 %element_leave_4119, 0
br i1 %compare_zero_leave_4119, label %loop_body_4119, label %post_loop_4119
post_loop_4119:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4119
; >ENTER_DEC_PTR 1038
%dataptr_1038 = load i32, i32* %dataptr_addr
%dec_dataptr_1038 = sub i32 %dataptr_1038, 19
store i32 %dec_dataptr_1038, i32* %dataptr_addr
; <ENTER_DEC_PTR 1038
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4120
%dataptr_leave_4120 = load i32, i32* %dataptr_addr
%element_addr_leave_4120 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4120
%element_leave_4120 = load i8, i8* %element_addr_leave_4120
%compare_zero_leave_4120 = icmp ne i8 %element_leave_4120, 0
br i1 %compare_zero_leave_4120, label %loop_body_4120, label %post_loop_4120
post_loop_4120:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4120
; >ENTER_INC_PTR 1058
%dataptr_1058 = load i32, i32* %dataptr_addr
%inc_dataptr_1058 = add i32 %dataptr_1058, 10
store i32 %inc_dataptr_1058, i32* %dataptr_addr
; <ENTER_INC_PTR 1058
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4132
%dataptr_enter_4132 = load i32, i32* %dataptr_addr
%element_addr_enter_4132 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4132
%element_enter_4132 = load i8, i8* %element_addr_enter_4132
%compare_zero_enter_4132 = icmp eq i8 %element_enter_4132, 0
br i1 %compare_zero_enter_4132, label %post_loop_4132, label %loop_body_4132
loop_body_4132:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4132
; >ENTER_INC_PTR 1070
%dataptr_1070 = load i32, i32* %dataptr_addr
%inc_dataptr_1070 = add i32 %dataptr_1070, 7
store i32 %inc_dataptr_1070, i32* %dataptr_addr
; <ENTER_INC_PTR 1070
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4131
%dataptr_enter_4131 = load i32, i32* %dataptr_addr
%element_addr_enter_4131 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4131
%element_enter_4131 = load i8, i8* %element_addr_enter_4131
%compare_zero_enter_4131 = icmp eq i8 %element_enter_4131, 0
br i1 %compare_zero_enter_4131, label %post_loop_4131, label %loop_body_4131
loop_body_4131:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4131
; >ENTER_DEC_DATA 1078
%dataptr_1078 = load i32, i32* %dataptr_addr
%element_addr_1078 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1078
%element_1078 = load i8, i8* %element_addr_1078
%sub_element_1078 = sub i8 %element_1078, 1
store i8 %sub_element_1078, i8* %element_addr_1078
; <ENTER_DEC_DATA 1078
; >ENTER_DEC_PTR 1079
%dataptr_1079 = load i32, i32* %dataptr_addr
%dec_dataptr_1079 = sub i32 %dataptr_1079, 1
store i32 %dec_dataptr_1079, i32* %dataptr_addr
; <ENTER_DEC_PTR 1079
; >ENTER_INC_DATA 1080
%dataptr_1080 = load i32, i32* %dataptr_addr
%element_addr_1080 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1080
%element_1080 = load i8, i8* %element_addr_1080
%inc_element_1080 = add i8 %element_1080, 1
store i8 %inc_element_1080, i8* %element_addr_1080
; <ENTER_INC_DATA 1080
; >ENTER_INC_PTR 1081
%dataptr_1081 = load i32, i32* %dataptr_addr
%inc_dataptr_1081 = add i32 %dataptr_1081, 1
store i32 %inc_dataptr_1081, i32* %dataptr_addr
; <ENTER_INC_PTR 1081
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4130
%dataptr_enter_4130 = load i32, i32* %dataptr_addr
%element_addr_enter_4130 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4130
%element_enter_4130 = load i8, i8* %element_addr_enter_4130
%compare_zero_enter_4130 = icmp eq i8 %element_enter_4130, 0
br i1 %compare_zero_enter_4130, label %post_loop_4130, label %loop_body_4130
loop_body_4130:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4130
; >ENTER_DEC_DATA 1083
%dataptr_1083 = load i32, i32* %dataptr_addr
%element_addr_1083 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1083
%element_1083 = load i8, i8* %element_addr_1083
%sub_element_1083 = sub i8 %element_1083, 1
store i8 %sub_element_1083, i8* %element_addr_1083
; <ENTER_DEC_DATA 1083
; >ENTER_DEC_PTR 1084
%dataptr_1084 = load i32, i32* %dataptr_addr
%dec_dataptr_1084 = sub i32 %dataptr_1084, 1
store i32 %dec_dataptr_1084, i32* %dataptr_addr
; <ENTER_DEC_PTR 1084
; >ENTER_INC_DATA 1085
%dataptr_1085 = load i32, i32* %dataptr_addr
%element_addr_1085 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1085
%element_1085 = load i8, i8* %element_addr_1085
%inc_element_1085 = add i8 %element_1085, 1
store i8 %inc_element_1085, i8* %element_addr_1085
; <ENTER_INC_DATA 1085
; >ENTER_INC_PTR 1086
%dataptr_1086 = load i32, i32* %dataptr_addr
%inc_dataptr_1086 = add i32 %dataptr_1086, 1
store i32 %inc_dataptr_1086, i32* %dataptr_addr
; <ENTER_INC_PTR 1086
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4129
%dataptr_enter_4129 = load i32, i32* %dataptr_addr
%element_addr_enter_4129 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4129
%element_enter_4129 = load i8, i8* %element_addr_enter_4129
%compare_zero_enter_4129 = icmp eq i8 %element_enter_4129, 0
br i1 %compare_zero_enter_4129, label %post_loop_4129, label %loop_body_4129
loop_body_4129:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4129
; >ENTER_DEC_DATA 1088
%dataptr_1088 = load i32, i32* %dataptr_addr
%element_addr_1088 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1088
%element_1088 = load i8, i8* %element_addr_1088
%sub_element_1088 = sub i8 %element_1088, 1
store i8 %sub_element_1088, i8* %element_addr_1088
; <ENTER_DEC_DATA 1088
; >ENTER_DEC_PTR 1089
%dataptr_1089 = load i32, i32* %dataptr_addr
%dec_dataptr_1089 = sub i32 %dataptr_1089, 1
store i32 %dec_dataptr_1089, i32* %dataptr_addr
; <ENTER_DEC_PTR 1089
; >ENTER_INC_DATA 1090
%dataptr_1090 = load i32, i32* %dataptr_addr
%element_addr_1090 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1090
%element_1090 = load i8, i8* %element_addr_1090
%inc_element_1090 = add i8 %element_1090, 1
store i8 %inc_element_1090, i8* %element_addr_1090
; <ENTER_INC_DATA 1090
; >ENTER_INC_PTR 1091
%dataptr_1091 = load i32, i32* %dataptr_addr
%inc_dataptr_1091 = add i32 %dataptr_1091, 1
store i32 %inc_dataptr_1091, i32* %dataptr_addr
; <ENTER_INC_PTR 1091
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4128
%dataptr_enter_4128 = load i32, i32* %dataptr_addr
%element_addr_enter_4128 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4128
%element_enter_4128 = load i8, i8* %element_addr_enter_4128
%compare_zero_enter_4128 = icmp eq i8 %element_enter_4128, 0
br i1 %compare_zero_enter_4128, label %post_loop_4128, label %loop_body_4128
loop_body_4128:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4128
; >ENTER_DEC_DATA 1093
%dataptr_1093 = load i32, i32* %dataptr_addr
%element_addr_1093 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1093
%element_1093 = load i8, i8* %element_addr_1093
%sub_element_1093 = sub i8 %element_1093, 1
store i8 %sub_element_1093, i8* %element_addr_1093
; <ENTER_DEC_DATA 1093
; >ENTER_DEC_PTR 1094
%dataptr_1094 = load i32, i32* %dataptr_addr
%dec_dataptr_1094 = sub i32 %dataptr_1094, 1
store i32 %dec_dataptr_1094, i32* %dataptr_addr
; <ENTER_DEC_PTR 1094
; >ENTER_INC_DATA 1095
%dataptr_1095 = load i32, i32* %dataptr_addr
%element_addr_1095 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1095
%element_1095 = load i8, i8* %element_addr_1095
%inc_element_1095 = add i8 %element_1095, 1
store i8 %inc_element_1095, i8* %element_addr_1095
; <ENTER_INC_DATA 1095
; >ENTER_INC_PTR 1096
%dataptr_1096 = load i32, i32* %dataptr_addr
%inc_dataptr_1096 = add i32 %dataptr_1096, 1
store i32 %inc_dataptr_1096, i32* %dataptr_addr
; <ENTER_INC_PTR 1096
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4127
%dataptr_enter_4127 = load i32, i32* %dataptr_addr
%element_addr_enter_4127 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4127
%element_enter_4127 = load i8, i8* %element_addr_enter_4127
%compare_zero_enter_4127 = icmp eq i8 %element_enter_4127, 0
br i1 %compare_zero_enter_4127, label %post_loop_4127, label %loop_body_4127
loop_body_4127:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4127
; >ENTER_DEC_DATA 1098
%dataptr_1098 = load i32, i32* %dataptr_addr
%element_addr_1098 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1098
%element_1098 = load i8, i8* %element_addr_1098
%sub_element_1098 = sub i8 %element_1098, 1
store i8 %sub_element_1098, i8* %element_addr_1098
; <ENTER_DEC_DATA 1098
; >ENTER_DEC_PTR 1099
%dataptr_1099 = load i32, i32* %dataptr_addr
%dec_dataptr_1099 = sub i32 %dataptr_1099, 1
store i32 %dec_dataptr_1099, i32* %dataptr_addr
; <ENTER_DEC_PTR 1099
; >ENTER_INC_DATA 1100
%dataptr_1100 = load i32, i32* %dataptr_addr
%element_addr_1100 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1100
%element_1100 = load i8, i8* %element_addr_1100
%inc_element_1100 = add i8 %element_1100, 1
store i8 %inc_element_1100, i8* %element_addr_1100
; <ENTER_INC_DATA 1100
; >ENTER_INC_PTR 1101
%dataptr_1101 = load i32, i32* %dataptr_addr
%inc_dataptr_1101 = add i32 %dataptr_1101, 1
store i32 %inc_dataptr_1101, i32* %dataptr_addr
; <ENTER_INC_PTR 1101
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4126
%dataptr_enter_4126 = load i32, i32* %dataptr_addr
%element_addr_enter_4126 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4126
%element_enter_4126 = load i8, i8* %element_addr_enter_4126
%compare_zero_enter_4126 = icmp eq i8 %element_enter_4126, 0
br i1 %compare_zero_enter_4126, label %post_loop_4126, label %loop_body_4126
loop_body_4126:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4126
; >ENTER_DEC_DATA 1103
%dataptr_1103 = load i32, i32* %dataptr_addr
%element_addr_1103 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1103
%element_1103 = load i8, i8* %element_addr_1103
%sub_element_1103 = sub i8 %element_1103, 1
store i8 %sub_element_1103, i8* %element_addr_1103
; <ENTER_DEC_DATA 1103
; >ENTER_DEC_PTR 1104
%dataptr_1104 = load i32, i32* %dataptr_addr
%dec_dataptr_1104 = sub i32 %dataptr_1104, 1
store i32 %dec_dataptr_1104, i32* %dataptr_addr
; <ENTER_DEC_PTR 1104
; >ENTER_INC_DATA 1105
%dataptr_1105 = load i32, i32* %dataptr_addr
%element_addr_1105 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1105
%element_1105 = load i8, i8* %element_addr_1105
%inc_element_1105 = add i8 %element_1105, 1
store i8 %inc_element_1105, i8* %element_addr_1105
; <ENTER_INC_DATA 1105
; >ENTER_INC_PTR 1106
%dataptr_1106 = load i32, i32* %dataptr_addr
%inc_dataptr_1106 = add i32 %dataptr_1106, 1
store i32 %inc_dataptr_1106, i32* %dataptr_addr
; <ENTER_INC_PTR 1106
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4125
%dataptr_enter_4125 = load i32, i32* %dataptr_addr
%element_addr_enter_4125 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4125
%element_enter_4125 = load i8, i8* %element_addr_enter_4125
%compare_zero_enter_4125 = icmp eq i8 %element_enter_4125, 0
br i1 %compare_zero_enter_4125, label %post_loop_4125, label %loop_body_4125
loop_body_4125:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4125
; >ENTER_DEC_DATA 1108
%dataptr_1108 = load i32, i32* %dataptr_addr
%element_addr_1108 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1108
%element_1108 = load i8, i8* %element_addr_1108
%sub_element_1108 = sub i8 %element_1108, 1
store i8 %sub_element_1108, i8* %element_addr_1108
; <ENTER_DEC_DATA 1108
; >ENTER_DEC_PTR 1109
%dataptr_1109 = load i32, i32* %dataptr_addr
%dec_dataptr_1109 = sub i32 %dataptr_1109, 1
store i32 %dec_dataptr_1109, i32* %dataptr_addr
; <ENTER_DEC_PTR 1109
; >ENTER_INC_DATA 1110
%dataptr_1110 = load i32, i32* %dataptr_addr
%element_addr_1110 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1110
%element_1110 = load i8, i8* %element_addr_1110
%inc_element_1110 = add i8 %element_1110, 1
store i8 %inc_element_1110, i8* %element_addr_1110
; <ENTER_INC_DATA 1110
; >ENTER_INC_PTR 1111
%dataptr_1111 = load i32, i32* %dataptr_addr
%inc_dataptr_1111 = add i32 %dataptr_1111, 1
store i32 %inc_dataptr_1111, i32* %dataptr_addr
; <ENTER_INC_PTR 1111
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4124
%dataptr_enter_4124 = load i32, i32* %dataptr_addr
%element_addr_enter_4124 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4124
%element_enter_4124 = load i8, i8* %element_addr_enter_4124
%compare_zero_enter_4124 = icmp eq i8 %element_enter_4124, 0
br i1 %compare_zero_enter_4124, label %post_loop_4124, label %loop_body_4124
loop_body_4124:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4124
; >ENTER_DEC_DATA 1113
%dataptr_1113 = load i32, i32* %dataptr_addr
%element_addr_1113 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1113
%element_1113 = load i8, i8* %element_addr_1113
%sub_element_1113 = sub i8 %element_1113, 1
store i8 %sub_element_1113, i8* %element_addr_1113
; <ENTER_DEC_DATA 1113
; >ENTER_DEC_PTR 1114
%dataptr_1114 = load i32, i32* %dataptr_addr
%dec_dataptr_1114 = sub i32 %dataptr_1114, 1
store i32 %dec_dataptr_1114, i32* %dataptr_addr
; <ENTER_DEC_PTR 1114
; >ENTER_INC_DATA 1115
%dataptr_1115 = load i32, i32* %dataptr_addr
%element_addr_1115 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1115
%element_1115 = load i8, i8* %element_addr_1115
%inc_element_1115 = add i8 %element_1115, 1
store i8 %inc_element_1115, i8* %element_addr_1115
; <ENTER_INC_DATA 1115
; >ENTER_INC_PTR 1116
%dataptr_1116 = load i32, i32* %dataptr_addr
%inc_dataptr_1116 = add i32 %dataptr_1116, 1
store i32 %inc_dataptr_1116, i32* %dataptr_addr
; <ENTER_INC_PTR 1116
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4123
%dataptr_enter_4123 = load i32, i32* %dataptr_addr
%element_addr_enter_4123 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4123
%element_enter_4123 = load i8, i8* %element_addr_enter_4123
%compare_zero_enter_4123 = icmp eq i8 %element_enter_4123, 0
br i1 %compare_zero_enter_4123, label %post_loop_4123, label %loop_body_4123
loop_body_4123:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4123
; >ENTER_DEC_DATA 1118
%dataptr_1118 = load i32, i32* %dataptr_addr
%element_addr_1118 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1118
%element_1118 = load i8, i8* %element_addr_1118
%sub_element_1118 = sub i8 %element_1118, 1
store i8 %sub_element_1118, i8* %element_addr_1118
; <ENTER_DEC_DATA 1118
; >ENTER_DEC_PTR 1119
%dataptr_1119 = load i32, i32* %dataptr_addr
%dec_dataptr_1119 = sub i32 %dataptr_1119, 1
store i32 %dec_dataptr_1119, i32* %dataptr_addr
; <ENTER_DEC_PTR 1119
; >ENTER_INC_DATA 1120
%dataptr_1120 = load i32, i32* %dataptr_addr
%element_addr_1120 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1120
%element_1120 = load i8, i8* %element_addr_1120
%inc_element_1120 = add i8 %element_1120, 1
store i8 %inc_element_1120, i8* %element_addr_1120
; <ENTER_INC_DATA 1120
; >ENTER_INC_PTR 1121
%dataptr_1121 = load i32, i32* %dataptr_addr
%inc_dataptr_1121 = add i32 %dataptr_1121, 1
store i32 %inc_dataptr_1121, i32* %dataptr_addr
; <ENTER_INC_PTR 1121
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4122
%dataptr_enter_4122 = load i32, i32* %dataptr_addr
%element_addr_enter_4122 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4122
%element_enter_4122 = load i8, i8* %element_addr_enter_4122
%compare_zero_enter_4122 = icmp eq i8 %element_enter_4122, 0
br i1 %compare_zero_enter_4122, label %post_loop_4122, label %loop_body_4122
loop_body_4122:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4122
; >ENTER_DEC_DATA 1124
%dataptr_1124 = load i32, i32* %dataptr_addr
%element_addr_1124 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1124
%element_1124 = load i8, i8* %element_addr_1124
%sub_element_1124 = sub i8 %element_1124, 1
store i8 %sub_element_1124, i8* %element_addr_1124
; <ENTER_DEC_DATA 1124
; >ENTER_DEC_PTR 1125
%dataptr_1125 = load i32, i32* %dataptr_addr
%dec_dataptr_1125 = sub i32 %dataptr_1125, 1
store i32 %dec_dataptr_1125, i32* %dataptr_addr
; <ENTER_DEC_PTR 1125
; >ENTER_DEC_DATA 1126
%dataptr_1126 = load i32, i32* %dataptr_addr
%element_addr_1126 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1126
%element_1126 = load i8, i8* %element_addr_1126
%sub_element_1126 = sub i8 %element_1126, 9
store i8 %sub_element_1126, i8* %element_addr_1126
; <ENTER_DEC_DATA 1126
; >ENTER_INC_PTR 1135
%dataptr_1135 = load i32, i32* %dataptr_addr
%inc_dataptr_1135 = add i32 %dataptr_1135, 11
store i32 %inc_dataptr_1135, i32* %dataptr_addr
; <ENTER_INC_PTR 1135
; >ENTER_INC_DATA 1146
%dataptr_1146 = load i32, i32* %dataptr_addr
%element_addr_1146 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1146
%element_1146 = load i8, i8* %element_addr_1146
%inc_element_1146 = add i8 %element_1146, 1
store i8 %inc_element_1146, i8* %element_addr_1146
; <ENTER_INC_DATA 1146
; >ENTER_DEC_PTR 1147
%dataptr_1147 = load i32, i32* %dataptr_addr
%dec_dataptr_1147 = sub i32 %dataptr_1147, 10
store i32 %dec_dataptr_1147, i32* %dataptr_addr
; <ENTER_DEC_PTR 1147
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4121
%dataptr_enter_4121 = load i32, i32* %dataptr_addr
%element_addr_enter_4121 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4121
%element_enter_4121 = load i8, i8* %element_addr_enter_4121
%compare_zero_enter_4121 = icmp eq i8 %element_enter_4121, 0
br i1 %compare_zero_enter_4121, label %post_loop_4121, label %loop_body_4121
loop_body_4121:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4121
; >ENTER_DEC_DATA 1158
%dataptr_1158 = load i32, i32* %dataptr_addr
%element_addr_1158 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1158
%element_1158 = load i8, i8* %element_addr_1158
%sub_element_1158 = sub i8 %element_1158, 1
store i8 %sub_element_1158, i8* %element_addr_1158
; <ENTER_DEC_DATA 1158
; >ENTER_DEC_PTR 1159
%dataptr_1159 = load i32, i32* %dataptr_addr
%dec_dataptr_1159 = sub i32 %dataptr_1159, 1
store i32 %dec_dataptr_1159, i32* %dataptr_addr
; <ENTER_DEC_PTR 1159
; >ENTER_INC_DATA 1160
%dataptr_1160 = load i32, i32* %dataptr_addr
%element_addr_1160 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1160
%element_1160 = load i8, i8* %element_addr_1160
%inc_element_1160 = add i8 %element_1160, 1
store i8 %inc_element_1160, i8* %element_addr_1160
; <ENTER_INC_DATA 1160
; >ENTER_INC_PTR 1161
%dataptr_1161 = load i32, i32* %dataptr_addr
%inc_dataptr_1161 = add i32 %dataptr_1161, 1
store i32 %inc_dataptr_1161, i32* %dataptr_addr
; <ENTER_INC_PTR 1161
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4121
%dataptr_leave_4121 = load i32, i32* %dataptr_addr
%element_addr_leave_4121 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4121
%element_leave_4121 = load i8, i8* %element_addr_leave_4121
%compare_zero_leave_4121 = icmp ne i8 %element_leave_4121, 0
br i1 %compare_zero_leave_4121, label %loop_body_4121, label %post_loop_4121
post_loop_4121:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4121
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4122
%dataptr_leave_4122 = load i32, i32* %dataptr_addr
%element_addr_leave_4122 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4122
%element_leave_4122 = load i8, i8* %element_addr_leave_4122
%compare_zero_leave_4122 = icmp ne i8 %element_leave_4122, 0
br i1 %compare_zero_leave_4122, label %loop_body_4122, label %post_loop_4122
post_loop_4122:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4122
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4123
%dataptr_leave_4123 = load i32, i32* %dataptr_addr
%element_addr_leave_4123 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4123
%element_leave_4123 = load i8, i8* %element_addr_leave_4123
%compare_zero_leave_4123 = icmp ne i8 %element_leave_4123, 0
br i1 %compare_zero_leave_4123, label %loop_body_4123, label %post_loop_4123
post_loop_4123:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4123
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4124
%dataptr_leave_4124 = load i32, i32* %dataptr_addr
%element_addr_leave_4124 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4124
%element_leave_4124 = load i8, i8* %element_addr_leave_4124
%compare_zero_leave_4124 = icmp ne i8 %element_leave_4124, 0
br i1 %compare_zero_leave_4124, label %loop_body_4124, label %post_loop_4124
post_loop_4124:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4124
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4125
%dataptr_leave_4125 = load i32, i32* %dataptr_addr
%element_addr_leave_4125 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4125
%element_leave_4125 = load i8, i8* %element_addr_leave_4125
%compare_zero_leave_4125 = icmp ne i8 %element_leave_4125, 0
br i1 %compare_zero_leave_4125, label %loop_body_4125, label %post_loop_4125
post_loop_4125:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4125
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4126
%dataptr_leave_4126 = load i32, i32* %dataptr_addr
%element_addr_leave_4126 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4126
%element_leave_4126 = load i8, i8* %element_addr_leave_4126
%compare_zero_leave_4126 = icmp ne i8 %element_leave_4126, 0
br i1 %compare_zero_leave_4126, label %loop_body_4126, label %post_loop_4126
post_loop_4126:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4126
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4127
%dataptr_leave_4127 = load i32, i32* %dataptr_addr
%element_addr_leave_4127 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4127
%element_leave_4127 = load i8, i8* %element_addr_leave_4127
%compare_zero_leave_4127 = icmp ne i8 %element_leave_4127, 0
br i1 %compare_zero_leave_4127, label %loop_body_4127, label %post_loop_4127
post_loop_4127:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4127
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4128
%dataptr_leave_4128 = load i32, i32* %dataptr_addr
%element_addr_leave_4128 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4128
%element_leave_4128 = load i8, i8* %element_addr_leave_4128
%compare_zero_leave_4128 = icmp ne i8 %element_leave_4128, 0
br i1 %compare_zero_leave_4128, label %loop_body_4128, label %post_loop_4128
post_loop_4128:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4128
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4129
%dataptr_leave_4129 = load i32, i32* %dataptr_addr
%element_addr_leave_4129 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4129
%element_leave_4129 = load i8, i8* %element_addr_leave_4129
%compare_zero_leave_4129 = icmp ne i8 %element_leave_4129, 0
br i1 %compare_zero_leave_4129, label %loop_body_4129, label %post_loop_4129
post_loop_4129:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4129
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4130
%dataptr_leave_4130 = load i32, i32* %dataptr_addr
%element_addr_leave_4130 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4130
%element_leave_4130 = load i8, i8* %element_addr_leave_4130
%compare_zero_leave_4130 = icmp ne i8 %element_leave_4130, 0
br i1 %compare_zero_leave_4130, label %loop_body_4130, label %post_loop_4130
post_loop_4130:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4130
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4131
%dataptr_leave_4131 = load i32, i32* %dataptr_addr
%element_addr_leave_4131 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4131
%element_leave_4131 = load i8, i8* %element_addr_leave_4131
%compare_zero_leave_4131 = icmp ne i8 %element_leave_4131, 0
br i1 %compare_zero_leave_4131, label %loop_body_4131, label %post_loop_4131
post_loop_4131:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4131
; >ENTER_INC_PTR 1173
%dataptr_1173 = load i32, i32* %dataptr_addr
%inc_dataptr_1173 = add i32 %dataptr_1173, 3
store i32 %inc_dataptr_1173, i32* %dataptr_addr
; <ENTER_INC_PTR 1173
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4132
%dataptr_leave_4132 = load i32, i32* %dataptr_addr
%element_addr_leave_4132 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4132
%element_leave_4132 = load i8, i8* %element_addr_leave_4132
%compare_zero_leave_4132 = icmp ne i8 %element_leave_4132, 0
br i1 %compare_zero_leave_4132, label %loop_body_4132, label %post_loop_4132
post_loop_4132:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4132
; >ENTER_DEC_PTR 1178
%dataptr_1178 = load i32, i32* %dataptr_addr
%dec_dataptr_1178 = sub i32 %dataptr_1178, 10
store i32 %dec_dataptr_1178, i32* %dataptr_addr
; <ENTER_DEC_PTR 1178
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4134
%dataptr_enter_4134 = load i32, i32* %dataptr_addr
%element_addr_enter_4134 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4134
%element_enter_4134 = load i8, i8* %element_addr_enter_4134
%compare_zero_enter_4134 = icmp eq i8 %element_enter_4134, 0
br i1 %compare_zero_enter_4134, label %post_loop_4134, label %loop_body_4134
loop_body_4134:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4134
; >ENTER_INC_PTR 1190
%dataptr_1190 = load i32, i32* %dataptr_addr
%inc_dataptr_1190 = add i32 %dataptr_1190, 4
store i32 %inc_dataptr_1190, i32* %dataptr_addr
; <ENTER_INC_PTR 1190
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4133
%dataptr_enter_4133 = load i32, i32* %dataptr_addr
%element_addr_enter_4133 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4133
%element_enter_4133 = load i8, i8* %element_addr_enter_4133
%compare_zero_enter_4133 = icmp eq i8 %element_enter_4133, 0
br i1 %compare_zero_enter_4133, label %post_loop_4133, label %loop_body_4133
loop_body_4133:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4133
; >ENTER_DEC_DATA 1195
%dataptr_1195 = load i32, i32* %dataptr_addr
%element_addr_1195 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1195
%element_1195 = load i8, i8* %element_addr_1195
%sub_element_1195 = sub i8 %element_1195, 1
store i8 %sub_element_1195, i8* %element_addr_1195
; <ENTER_DEC_DATA 1195
; >ENTER_INC_PTR 1196
%dataptr_1196 = load i32, i32* %dataptr_addr
%inc_dataptr_1196 = add i32 %dataptr_1196, 3
store i32 %inc_dataptr_1196, i32* %dataptr_addr
; <ENTER_INC_PTR 1196
; >ENTER_INC_DATA 1199
%dataptr_1199 = load i32, i32* %dataptr_addr
%element_addr_1199 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1199
%element_1199 = load i8, i8* %element_addr_1199
%inc_element_1199 = add i8 %element_1199, 1
store i8 %inc_element_1199, i8* %element_addr_1199
; <ENTER_INC_DATA 1199
; >ENTER_INC_PTR 1200
%dataptr_1200 = load i32, i32* %dataptr_addr
%inc_dataptr_1200 = add i32 %dataptr_1200, 2
store i32 %inc_dataptr_1200, i32* %dataptr_addr
; <ENTER_INC_PTR 1200
; >ENTER_INC_DATA 1202
%dataptr_1202 = load i32, i32* %dataptr_addr
%element_addr_1202 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1202
%element_1202 = load i8, i8* %element_addr_1202
%inc_element_1202 = add i8 %element_1202, 1
store i8 %inc_element_1202, i8* %element_addr_1202
; <ENTER_INC_DATA 1202
; >ENTER_DEC_PTR 1203
%dataptr_1203 = load i32, i32* %dataptr_addr
%dec_dataptr_1203 = sub i32 %dataptr_1203, 5
store i32 %dec_dataptr_1203, i32* %dataptr_addr
; <ENTER_DEC_PTR 1203
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4133
%dataptr_leave_4133 = load i32, i32* %dataptr_addr
%element_addr_leave_4133 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4133
%element_leave_4133 = load i8, i8* %element_addr_leave_4133
%compare_zero_leave_4133 = icmp ne i8 %element_leave_4133, 0
br i1 %compare_zero_leave_4133, label %loop_body_4133, label %post_loop_4133
post_loop_4133:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4133
; >ENTER_DEC_PTR 1209
%dataptr_1209 = load i32, i32* %dataptr_addr
%dec_dataptr_1209 = sub i32 %dataptr_1209, 14
store i32 %dec_dataptr_1209, i32* %dataptr_addr
; <ENTER_DEC_PTR 1209
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4134
%dataptr_leave_4134 = load i32, i32* %dataptr_addr
%element_addr_leave_4134 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4134
%element_leave_4134 = load i8, i8* %element_addr_leave_4134
%compare_zero_leave_4134 = icmp ne i8 %element_leave_4134, 0
br i1 %compare_zero_leave_4134, label %loop_body_4134, label %post_loop_4134
post_loop_4134:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4134
; >ENTER_INC_PTR 1225
%dataptr_1225 = load i32, i32* %dataptr_addr
%inc_dataptr_1225 = add i32 %dataptr_1225, 10
store i32 %inc_dataptr_1225, i32* %dataptr_addr
; <ENTER_INC_PTR 1225
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4136
%dataptr_enter_4136 = load i32, i32* %dataptr_addr
%element_addr_enter_4136 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4136
%element_enter_4136 = load i8, i8* %element_addr_enter_4136
%compare_zero_enter_4136 = icmp eq i8 %element_enter_4136, 0
br i1 %compare_zero_enter_4136, label %post_loop_4136, label %loop_body_4136
loop_body_4136:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4136
; >ENTER_INC_PTR 1236
%dataptr_1236 = load i32, i32* %dataptr_addr
%inc_dataptr_1236 = add i32 %dataptr_1236, 7
store i32 %inc_dataptr_1236, i32* %dataptr_addr
; <ENTER_INC_PTR 1236
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4135
%dataptr_enter_4135 = load i32, i32* %dataptr_addr
%element_addr_enter_4135 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4135
%element_enter_4135 = load i8, i8* %element_addr_enter_4135
%compare_zero_enter_4135 = icmp eq i8 %element_enter_4135, 0
br i1 %compare_zero_enter_4135, label %post_loop_4135, label %loop_body_4135
loop_body_4135:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4135
; >ENTER_DEC_DATA 1244
%dataptr_1244 = load i32, i32* %dataptr_addr
%element_addr_1244 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1244
%element_1244 = load i8, i8* %element_addr_1244
%sub_element_1244 = sub i8 %element_1244, 1
store i8 %sub_element_1244, i8* %element_addr_1244
; <ENTER_DEC_DATA 1244
; >ENTER_DEC_PTR 1245
%dataptr_1245 = load i32, i32* %dataptr_addr
%dec_dataptr_1245 = sub i32 %dataptr_1245, 3
store i32 %dec_dataptr_1245, i32* %dataptr_addr
; <ENTER_DEC_PTR 1245
; >ENTER_INC_DATA 1248
%dataptr_1248 = load i32, i32* %dataptr_addr
%element_addr_1248 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1248
%element_1248 = load i8, i8* %element_addr_1248
%inc_element_1248 = add i8 %element_1248, 1
store i8 %inc_element_1248, i8* %element_addr_1248
; <ENTER_INC_DATA 1248
; >ENTER_INC_PTR 1249
%dataptr_1249 = load i32, i32* %dataptr_addr
%inc_dataptr_1249 = add i32 %dataptr_1249, 3
store i32 %inc_dataptr_1249, i32* %dataptr_addr
; <ENTER_INC_PTR 1249
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4135
%dataptr_leave_4135 = load i32, i32* %dataptr_addr
%element_addr_leave_4135 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4135
%element_leave_4135 = load i8, i8* %element_addr_leave_4135
%compare_zero_leave_4135 = icmp ne i8 %element_leave_4135, 0
br i1 %compare_zero_leave_4135, label %loop_body_4135, label %post_loop_4135
post_loop_4135:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4135
; >ENTER_INC_PTR 1253
%dataptr_1253 = load i32, i32* %dataptr_addr
%inc_dataptr_1253 = add i32 %dataptr_1253, 3
store i32 %inc_dataptr_1253, i32* %dataptr_addr
; <ENTER_INC_PTR 1253
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4136
%dataptr_leave_4136 = load i32, i32* %dataptr_addr
%element_addr_leave_4136 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4136
%element_leave_4136 = load i8, i8* %element_addr_leave_4136
%compare_zero_leave_4136 = icmp ne i8 %element_leave_4136, 0
br i1 %compare_zero_leave_4136, label %loop_body_4136, label %post_loop_4136
post_loop_4136:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4136
; >ENTER_DEC_PTR 1257
%dataptr_1257 = load i32, i32* %dataptr_addr
%dec_dataptr_1257 = sub i32 %dataptr_1257, 10
store i32 %dec_dataptr_1257, i32* %dataptr_addr
; <ENTER_DEC_PTR 1257
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4142
%dataptr_enter_4142 = load i32, i32* %dataptr_addr
%element_addr_enter_4142 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4142
%element_enter_4142 = load i8, i8* %element_addr_enter_4142
%compare_zero_enter_4142 = icmp eq i8 %element_enter_4142, 0
br i1 %compare_zero_enter_4142, label %post_loop_4142, label %loop_body_4142
loop_body_4142:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4142
; >ENTER_INC_PTR 1269
%dataptr_1269 = load i32, i32* %dataptr_addr
%inc_dataptr_1269 = add i32 %dataptr_1269, 8
store i32 %inc_dataptr_1269, i32* %dataptr_addr
; <ENTER_INC_PTR 1269
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4137
%dataptr_enter_4137 = load i32, i32* %dataptr_addr
%element_addr_enter_4137 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4137
%element_enter_4137 = load i8, i8* %element_addr_enter_4137
%compare_zero_enter_4137 = icmp eq i8 %element_enter_4137, 0
br i1 %compare_zero_enter_4137, label %post_loop_4137, label %loop_body_4137
loop_body_4137:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4137
; >ENTER_DEC_DATA 1278
%dataptr_1278 = load i32, i32* %dataptr_addr
%element_addr_1278 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1278
%element_1278 = load i8, i8* %element_addr_1278
%sub_element_1278 = sub i8 %element_1278, 1
store i8 %sub_element_1278, i8* %element_addr_1278
; <ENTER_DEC_DATA 1278
; >ENTER_INC_PTR 1279
%dataptr_1279 = load i32, i32* %dataptr_addr
%inc_dataptr_1279 = add i32 %dataptr_1279, 1
store i32 %inc_dataptr_1279, i32* %dataptr_addr
; <ENTER_INC_PTR 1279
; >ENTER_DEC_DATA 1280
%dataptr_1280 = load i32, i32* %dataptr_addr
%element_addr_1280 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1280
%element_1280 = load i8, i8* %element_addr_1280
%sub_element_1280 = sub i8 %element_1280, 1
store i8 %sub_element_1280, i8* %element_addr_1280
; <ENTER_DEC_DATA 1280
; >ENTER_DEC_PTR 1281
%dataptr_1281 = load i32, i32* %dataptr_addr
%dec_dataptr_1281 = sub i32 %dataptr_1281, 1
store i32 %dec_dataptr_1281, i32* %dataptr_addr
; <ENTER_DEC_PTR 1281
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4137
%dataptr_leave_4137 = load i32, i32* %dataptr_addr
%element_addr_leave_4137 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4137
%element_leave_4137 = load i8, i8* %element_addr_leave_4137
%compare_zero_leave_4137 = icmp ne i8 %element_leave_4137, 0
br i1 %compare_zero_leave_4137, label %loop_body_4137, label %post_loop_4137
post_loop_4137:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4137
; >ENTER_INC_PTR 1283
%dataptr_1283 = load i32, i32* %dataptr_addr
%inc_dataptr_1283 = add i32 %dataptr_1283, 1
store i32 %inc_dataptr_1283, i32* %dataptr_addr
; <ENTER_INC_PTR 1283
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4141
%dataptr_enter_4141 = load i32, i32* %dataptr_addr
%element_addr_enter_4141 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4141
%element_enter_4141 = load i8, i8* %element_addr_enter_4141
%compare_zero_enter_4141 = icmp eq i8 %element_enter_4141, 0
br i1 %compare_zero_enter_4141, label %post_loop_4141, label %loop_body_4141
loop_body_4141:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4141
; >ENTER_DEC_PTR 1286
%dataptr_1286 = load i32, i32* %dataptr_addr
%dec_dataptr_1286 = sub i32 %dataptr_1286, 9
store i32 %dec_dataptr_1286, i32* %dataptr_addr
; <ENTER_DEC_PTR 1286
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4140
%dataptr_enter_4140 = load i32, i32* %dataptr_addr
%element_addr_enter_4140 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4140
%element_enter_4140 = load i8, i8* %element_addr_enter_4140
%compare_zero_enter_4140 = icmp eq i8 %element_enter_4140, 0
br i1 %compare_zero_enter_4140, label %post_loop_4140, label %loop_body_4140
loop_body_4140:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4140
; >ENTER_DEC_PTR 1296
%dataptr_1296 = load i32, i32* %dataptr_addr
%dec_dataptr_1296 = sub i32 %dataptr_1296, 1
store i32 %dec_dataptr_1296, i32* %dataptr_addr
; <ENTER_DEC_PTR 1296
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4138
%dataptr_enter_4138 = load i32, i32* %dataptr_addr
%element_addr_enter_4138 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4138
%element_enter_4138 = load i8, i8* %element_addr_enter_4138
%compare_zero_enter_4138 = icmp eq i8 %element_enter_4138, 0
br i1 %compare_zero_enter_4138, label %post_loop_4138, label %loop_body_4138
loop_body_4138:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4138
; >ENTER_DEC_DATA 1298
%dataptr_1298 = load i32, i32* %dataptr_addr
%element_addr_1298 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1298
%element_1298 = load i8, i8* %element_addr_1298
%sub_element_1298 = sub i8 %element_1298, 1
store i8 %sub_element_1298, i8* %element_addr_1298
; <ENTER_DEC_DATA 1298
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4138
%dataptr_leave_4138 = load i32, i32* %dataptr_addr
%element_addr_leave_4138 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4138
%element_leave_4138 = load i8, i8* %element_addr_leave_4138
%compare_zero_leave_4138 = icmp ne i8 %element_leave_4138, 0
br i1 %compare_zero_leave_4138, label %loop_body_4138, label %post_loop_4138
post_loop_4138:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4138
; >ENTER_INC_PTR 1300
%dataptr_1300 = load i32, i32* %dataptr_addr
%inc_dataptr_1300 = add i32 %dataptr_1300, 10
store i32 %inc_dataptr_1300, i32* %dataptr_addr
; <ENTER_INC_PTR 1300
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4139
%dataptr_enter_4139 = load i32, i32* %dataptr_addr
%element_addr_enter_4139 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4139
%element_enter_4139 = load i8, i8* %element_addr_enter_4139
%compare_zero_enter_4139 = icmp eq i8 %element_enter_4139, 0
br i1 %compare_zero_enter_4139, label %post_loop_4139, label %loop_body_4139
loop_body_4139:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4139
; >ENTER_DEC_DATA 1311
%dataptr_1311 = load i32, i32* %dataptr_addr
%element_addr_1311 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1311
%element_1311 = load i8, i8* %element_addr_1311
%sub_element_1311 = sub i8 %element_1311, 1
store i8 %sub_element_1311, i8* %element_addr_1311
; <ENTER_DEC_DATA 1311
; >ENTER_DEC_PTR 1312
%dataptr_1312 = load i32, i32* %dataptr_addr
%dec_dataptr_1312 = sub i32 %dataptr_1312, 10
store i32 %dec_dataptr_1312, i32* %dataptr_addr
; <ENTER_DEC_PTR 1312
; >ENTER_INC_DATA 1322
%dataptr_1322 = load i32, i32* %dataptr_addr
%element_addr_1322 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1322
%element_1322 = load i8, i8* %element_addr_1322
%inc_element_1322 = add i8 %element_1322, 1
store i8 %inc_element_1322, i8* %element_addr_1322
; <ENTER_INC_DATA 1322
; >ENTER_INC_PTR 1323
%dataptr_1323 = load i32, i32* %dataptr_addr
%inc_dataptr_1323 = add i32 %dataptr_1323, 10
store i32 %inc_dataptr_1323, i32* %dataptr_addr
; <ENTER_INC_PTR 1323
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4139
%dataptr_leave_4139 = load i32, i32* %dataptr_addr
%element_addr_leave_4139 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4139
%element_leave_4139 = load i8, i8* %element_addr_leave_4139
%compare_zero_leave_4139 = icmp ne i8 %element_leave_4139, 0
br i1 %compare_zero_leave_4139, label %loop_body_4139, label %post_loop_4139
post_loop_4139:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4139
; >ENTER_DEC_PTR 1334
%dataptr_1334 = load i32, i32* %dataptr_addr
%dec_dataptr_1334 = sub i32 %dataptr_1334, 19
store i32 %dec_dataptr_1334, i32* %dataptr_addr
; <ENTER_DEC_PTR 1334
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4140
%dataptr_leave_4140 = load i32, i32* %dataptr_addr
%element_addr_leave_4140 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4140
%element_leave_4140 = load i8, i8* %element_addr_leave_4140
%compare_zero_leave_4140 = icmp ne i8 %element_leave_4140, 0
br i1 %compare_zero_leave_4140, label %loop_body_4140, label %post_loop_4140
post_loop_4140:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4140
; >ENTER_INC_PTR 1355
%dataptr_1355 = load i32, i32* %dataptr_addr
%inc_dataptr_1355 = add i32 %dataptr_1355, 19
store i32 %inc_dataptr_1355, i32* %dataptr_addr
; <ENTER_INC_PTR 1355
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4141
%dataptr_leave_4141 = load i32, i32* %dataptr_addr
%element_addr_leave_4141 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4141
%element_leave_4141 = load i8, i8* %element_addr_leave_4141
%compare_zero_leave_4141 = icmp ne i8 %element_leave_4141, 0
br i1 %compare_zero_leave_4141, label %loop_body_4141, label %post_loop_4141
post_loop_4141:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4141
; >ENTER_DEC_PTR 1376
%dataptr_1376 = load i32, i32* %dataptr_addr
%dec_dataptr_1376 = sub i32 %dataptr_1376, 19
store i32 %dec_dataptr_1376, i32* %dataptr_addr
; <ENTER_DEC_PTR 1376
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4142
%dataptr_leave_4142 = load i32, i32* %dataptr_addr
%element_addr_leave_4142 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4142
%element_leave_4142 = load i8, i8* %element_addr_leave_4142
%compare_zero_leave_4142 = icmp ne i8 %element_leave_4142, 0
br i1 %compare_zero_leave_4142, label %loop_body_4142, label %post_loop_4142
post_loop_4142:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4142
; >ENTER_INC_PTR 1397
%dataptr_1397 = load i32, i32* %dataptr_addr
%inc_dataptr_1397 = add i32 %dataptr_1397, 9
store i32 %inc_dataptr_1397, i32* %dataptr_addr
; <ENTER_INC_PTR 1397
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4154
%dataptr_enter_4154 = load i32, i32* %dataptr_addr
%element_addr_enter_4154 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4154
%element_enter_4154 = load i8, i8* %element_addr_enter_4154
%compare_zero_enter_4154 = icmp eq i8 %element_enter_4154, 0
br i1 %compare_zero_enter_4154, label %post_loop_4154, label %loop_body_4154
loop_body_4154:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4154
; >ENTER_INC_DATA 1407
%dataptr_1407 = load i32, i32* %dataptr_addr
%element_addr_1407 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1407
%element_1407 = load i8, i8* %element_addr_1407
%inc_element_1407 = add i8 %element_1407, 1
store i8 %inc_element_1407, i8* %element_addr_1407
; <ENTER_INC_DATA 1407
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4153
%dataptr_enter_4153 = load i32, i32* %dataptr_addr
%element_addr_enter_4153 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4153
%element_enter_4153 = load i8, i8* %element_addr_enter_4153
%compare_zero_enter_4153 = icmp eq i8 %element_enter_4153, 0
br i1 %compare_zero_enter_4153, label %post_loop_4153, label %loop_body_4153
loop_body_4153:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4153
; >ENTER_INC_DATA 1409
%dataptr_1409 = load i32, i32* %dataptr_addr
%element_addr_1409 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1409
%element_1409 = load i8, i8* %element_addr_1409
%inc_element_1409 = add i8 %element_1409, 1
store i8 %inc_element_1409, i8* %element_addr_1409
; <ENTER_INC_DATA 1409
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4152
%dataptr_enter_4152 = load i32, i32* %dataptr_addr
%element_addr_enter_4152 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4152
%element_enter_4152 = load i8, i8* %element_addr_enter_4152
%compare_zero_enter_4152 = icmp eq i8 %element_enter_4152, 0
br i1 %compare_zero_enter_4152, label %post_loop_4152, label %loop_body_4152
loop_body_4152:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4152
; >ENTER_INC_DATA 1411
%dataptr_1411 = load i32, i32* %dataptr_addr
%element_addr_1411 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1411
%element_1411 = load i8, i8* %element_addr_1411
%inc_element_1411 = add i8 %element_1411, 1
store i8 %inc_element_1411, i8* %element_addr_1411
; <ENTER_INC_DATA 1411
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4151
%dataptr_enter_4151 = load i32, i32* %dataptr_addr
%element_addr_enter_4151 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4151
%element_enter_4151 = load i8, i8* %element_addr_enter_4151
%compare_zero_enter_4151 = icmp eq i8 %element_enter_4151, 0
br i1 %compare_zero_enter_4151, label %post_loop_4151, label %loop_body_4151
loop_body_4151:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4151
; >ENTER_INC_DATA 1413
%dataptr_1413 = load i32, i32* %dataptr_addr
%element_addr_1413 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1413
%element_1413 = load i8, i8* %element_addr_1413
%inc_element_1413 = add i8 %element_1413, 1
store i8 %inc_element_1413, i8* %element_addr_1413
; <ENTER_INC_DATA 1413
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4150
%dataptr_enter_4150 = load i32, i32* %dataptr_addr
%element_addr_enter_4150 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4150
%element_enter_4150 = load i8, i8* %element_addr_enter_4150
%compare_zero_enter_4150 = icmp eq i8 %element_enter_4150, 0
br i1 %compare_zero_enter_4150, label %post_loop_4150, label %loop_body_4150
loop_body_4150:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4150
; >ENTER_INC_DATA 1415
%dataptr_1415 = load i32, i32* %dataptr_addr
%element_addr_1415 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1415
%element_1415 = load i8, i8* %element_addr_1415
%inc_element_1415 = add i8 %element_1415, 1
store i8 %inc_element_1415, i8* %element_addr_1415
; <ENTER_INC_DATA 1415
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4149
%dataptr_enter_4149 = load i32, i32* %dataptr_addr
%element_addr_enter_4149 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4149
%element_enter_4149 = load i8, i8* %element_addr_enter_4149
%compare_zero_enter_4149 = icmp eq i8 %element_enter_4149, 0
br i1 %compare_zero_enter_4149, label %post_loop_4149, label %loop_body_4149
loop_body_4149:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4149
; >ENTER_INC_DATA 1417
%dataptr_1417 = load i32, i32* %dataptr_addr
%element_addr_1417 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1417
%element_1417 = load i8, i8* %element_addr_1417
%inc_element_1417 = add i8 %element_1417, 1
store i8 %inc_element_1417, i8* %element_addr_1417
; <ENTER_INC_DATA 1417
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4148
%dataptr_enter_4148 = load i32, i32* %dataptr_addr
%element_addr_enter_4148 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4148
%element_enter_4148 = load i8, i8* %element_addr_enter_4148
%compare_zero_enter_4148 = icmp eq i8 %element_enter_4148, 0
br i1 %compare_zero_enter_4148, label %post_loop_4148, label %loop_body_4148
loop_body_4148:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4148
; >ENTER_INC_DATA 1419
%dataptr_1419 = load i32, i32* %dataptr_addr
%element_addr_1419 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1419
%element_1419 = load i8, i8* %element_addr_1419
%inc_element_1419 = add i8 %element_1419, 1
store i8 %inc_element_1419, i8* %element_addr_1419
; <ENTER_INC_DATA 1419
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4147
%dataptr_enter_4147 = load i32, i32* %dataptr_addr
%element_addr_enter_4147 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4147
%element_enter_4147 = load i8, i8* %element_addr_enter_4147
%compare_zero_enter_4147 = icmp eq i8 %element_enter_4147, 0
br i1 %compare_zero_enter_4147, label %post_loop_4147, label %loop_body_4147
loop_body_4147:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4147
; >ENTER_INC_DATA 1421
%dataptr_1421 = load i32, i32* %dataptr_addr
%element_addr_1421 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1421
%element_1421 = load i8, i8* %element_addr_1421
%inc_element_1421 = add i8 %element_1421, 1
store i8 %inc_element_1421, i8* %element_addr_1421
; <ENTER_INC_DATA 1421
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4146
%dataptr_enter_4146 = load i32, i32* %dataptr_addr
%element_addr_enter_4146 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4146
%element_enter_4146 = load i8, i8* %element_addr_enter_4146
%compare_zero_enter_4146 = icmp eq i8 %element_enter_4146, 0
br i1 %compare_zero_enter_4146, label %post_loop_4146, label %loop_body_4146
loop_body_4146:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4146
; >ENTER_INC_DATA 1423
%dataptr_1423 = load i32, i32* %dataptr_addr
%element_addr_1423 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1423
%element_1423 = load i8, i8* %element_addr_1423
%inc_element_1423 = add i8 %element_1423, 1
store i8 %inc_element_1423, i8* %element_addr_1423
; <ENTER_INC_DATA 1423
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4145
%dataptr_enter_4145 = load i32, i32* %dataptr_addr
%element_addr_enter_4145 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4145
%element_enter_4145 = load i8, i8* %element_addr_enter_4145
%compare_zero_enter_4145 = icmp eq i8 %element_enter_4145, 0
br i1 %compare_zero_enter_4145, label %post_loop_4145, label %loop_body_4145
loop_body_4145:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4145
; >ENTER_INC_DATA 1425
%dataptr_1425 = load i32, i32* %dataptr_addr
%element_addr_1425 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1425
%element_1425 = load i8, i8* %element_addr_1425
%inc_element_1425 = add i8 %element_1425, 1
store i8 %inc_element_1425, i8* %element_addr_1425
; <ENTER_INC_DATA 1425
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4144
%dataptr_enter_4144 = load i32, i32* %dataptr_addr
%element_addr_enter_4144 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4144
%element_enter_4144 = load i8, i8* %element_addr_enter_4144
%compare_zero_enter_4144 = icmp eq i8 %element_enter_4144, 0
br i1 %compare_zero_enter_4144, label %post_loop_4144, label %loop_body_4144
loop_body_4144:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4144
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4143
%dataptr_enter_4143 = load i32, i32* %dataptr_addr
%element_addr_enter_4143 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4143
%element_enter_4143 = load i8, i8* %element_addr_enter_4143
%compare_zero_enter_4143 = icmp eq i8 %element_enter_4143, 0
br i1 %compare_zero_enter_4143, label %post_loop_4143, label %loop_body_4143
loop_body_4143:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4143
; >ENTER_DEC_DATA 1428
%dataptr_1428 = load i32, i32* %dataptr_addr
%element_addr_1428 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1428
%element_1428 = load i8, i8* %element_addr_1428
%sub_element_1428 = sub i8 %element_1428, 1
store i8 %sub_element_1428, i8* %element_addr_1428
; <ENTER_DEC_DATA 1428
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4143
%dataptr_leave_4143 = load i32, i32* %dataptr_addr
%element_addr_leave_4143 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4143
%element_leave_4143 = load i8, i8* %element_addr_leave_4143
%compare_zero_leave_4143 = icmp ne i8 %element_leave_4143, 0
br i1 %compare_zero_leave_4143, label %loop_body_4143, label %post_loop_4143
post_loop_4143:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4143
; >ENTER_DEC_PTR 1430
%dataptr_1430 = load i32, i32* %dataptr_addr
%dec_dataptr_1430 = sub i32 %dataptr_1430, 1
store i32 %dec_dataptr_1430, i32* %dataptr_addr
; <ENTER_DEC_PTR 1430
; >ENTER_INC_DATA 1431
%dataptr_1431 = load i32, i32* %dataptr_addr
%element_addr_1431 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1431
%element_1431 = load i8, i8* %element_addr_1431
%inc_element_1431 = add i8 %element_1431, 1
store i8 %inc_element_1431, i8* %element_addr_1431
; <ENTER_INC_DATA 1431
; >ENTER_INC_PTR 1432
%dataptr_1432 = load i32, i32* %dataptr_addr
%inc_dataptr_1432 = add i32 %dataptr_1432, 1
store i32 %inc_dataptr_1432, i32* %dataptr_addr
; <ENTER_INC_PTR 1432
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4144
%dataptr_leave_4144 = load i32, i32* %dataptr_addr
%element_addr_leave_4144 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4144
%element_leave_4144 = load i8, i8* %element_addr_leave_4144
%compare_zero_leave_4144 = icmp ne i8 %element_leave_4144, 0
br i1 %compare_zero_leave_4144, label %loop_body_4144, label %post_loop_4144
post_loop_4144:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4144
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4145
%dataptr_leave_4145 = load i32, i32* %dataptr_addr
%element_addr_leave_4145 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4145
%element_leave_4145 = load i8, i8* %element_addr_leave_4145
%compare_zero_leave_4145 = icmp ne i8 %element_leave_4145, 0
br i1 %compare_zero_leave_4145, label %loop_body_4145, label %post_loop_4145
post_loop_4145:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4145
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4146
%dataptr_leave_4146 = load i32, i32* %dataptr_addr
%element_addr_leave_4146 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4146
%element_leave_4146 = load i8, i8* %element_addr_leave_4146
%compare_zero_leave_4146 = icmp ne i8 %element_leave_4146, 0
br i1 %compare_zero_leave_4146, label %loop_body_4146, label %post_loop_4146
post_loop_4146:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4146
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4147
%dataptr_leave_4147 = load i32, i32* %dataptr_addr
%element_addr_leave_4147 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4147
%element_leave_4147 = load i8, i8* %element_addr_leave_4147
%compare_zero_leave_4147 = icmp ne i8 %element_leave_4147, 0
br i1 %compare_zero_leave_4147, label %loop_body_4147, label %post_loop_4147
post_loop_4147:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4147
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4148
%dataptr_leave_4148 = load i32, i32* %dataptr_addr
%element_addr_leave_4148 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4148
%element_leave_4148 = load i8, i8* %element_addr_leave_4148
%compare_zero_leave_4148 = icmp ne i8 %element_leave_4148, 0
br i1 %compare_zero_leave_4148, label %loop_body_4148, label %post_loop_4148
post_loop_4148:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4148
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4149
%dataptr_leave_4149 = load i32, i32* %dataptr_addr
%element_addr_leave_4149 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4149
%element_leave_4149 = load i8, i8* %element_addr_leave_4149
%compare_zero_leave_4149 = icmp ne i8 %element_leave_4149, 0
br i1 %compare_zero_leave_4149, label %loop_body_4149, label %post_loop_4149
post_loop_4149:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4149
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4150
%dataptr_leave_4150 = load i32, i32* %dataptr_addr
%element_addr_leave_4150 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4150
%element_leave_4150 = load i8, i8* %element_addr_leave_4150
%compare_zero_leave_4150 = icmp ne i8 %element_leave_4150, 0
br i1 %compare_zero_leave_4150, label %loop_body_4150, label %post_loop_4150
post_loop_4150:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4150
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4151
%dataptr_leave_4151 = load i32, i32* %dataptr_addr
%element_addr_leave_4151 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4151
%element_leave_4151 = load i8, i8* %element_addr_leave_4151
%compare_zero_leave_4151 = icmp ne i8 %element_leave_4151, 0
br i1 %compare_zero_leave_4151, label %loop_body_4151, label %post_loop_4151
post_loop_4151:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4151
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4152
%dataptr_leave_4152 = load i32, i32* %dataptr_addr
%element_addr_leave_4152 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4152
%element_leave_4152 = load i8, i8* %element_addr_leave_4152
%compare_zero_leave_4152 = icmp ne i8 %element_leave_4152, 0
br i1 %compare_zero_leave_4152, label %loop_body_4152, label %post_loop_4152
post_loop_4152:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4152
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4153
%dataptr_leave_4153 = load i32, i32* %dataptr_addr
%element_addr_leave_4153 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4153
%element_leave_4153 = load i8, i8* %element_addr_leave_4153
%compare_zero_leave_4153 = icmp ne i8 %element_leave_4153, 0
br i1 %compare_zero_leave_4153, label %loop_body_4153, label %post_loop_4153
post_loop_4153:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4153
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4154
%dataptr_leave_4154 = load i32, i32* %dataptr_addr
%element_addr_leave_4154 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4154
%element_leave_4154 = load i8, i8* %element_addr_leave_4154
%compare_zero_leave_4154 = icmp ne i8 %element_leave_4154, 0
br i1 %compare_zero_leave_4154, label %loop_body_4154, label %post_loop_4154
post_loop_4154:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4154
; >ENTER_DEC_PTR 1444
%dataptr_1444 = load i32, i32* %dataptr_addr
%dec_dataptr_1444 = sub i32 %dataptr_1444, 1
store i32 %dec_dataptr_1444, i32* %dataptr_addr
; <ENTER_DEC_PTR 1444
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4155
%dataptr_leave_4155 = load i32, i32* %dataptr_addr
%element_addr_leave_4155 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4155
%element_leave_4155 = load i8, i8* %element_addr_leave_4155
%compare_zero_leave_4155 = icmp ne i8 %element_leave_4155, 0
br i1 %compare_zero_leave_4155, label %loop_body_4155, label %post_loop_4155
post_loop_4155:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4155
; >ENTER_INC_PTR 1448
%dataptr_1448 = load i32, i32* %dataptr_addr
%inc_dataptr_1448 = add i32 %dataptr_1448, 8
store i32 %inc_dataptr_1448, i32* %dataptr_addr
; <ENTER_INC_PTR 1448
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4236
%dataptr_enter_4236 = load i32, i32* %dataptr_addr
%element_addr_enter_4236 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4236
%element_enter_4236 = load i8, i8* %element_addr_enter_4236
%compare_zero_enter_4236 = icmp eq i8 %element_enter_4236, 0
br i1 %compare_zero_enter_4236, label %post_loop_4236, label %loop_body_4236
loop_body_4236:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4236
; >ENTER_DEC_PTR 1459
%dataptr_1459 = load i32, i32* %dataptr_addr
%dec_dataptr_1459 = sub i32 %dataptr_1459, 6
store i32 %dec_dataptr_1459, i32* %dataptr_addr
; <ENTER_DEC_PTR 1459
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4159
%dataptr_enter_4159 = load i32, i32* %dataptr_addr
%element_addr_enter_4159 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4159
%element_enter_4159 = load i8, i8* %element_addr_enter_4159
%compare_zero_enter_4159 = icmp eq i8 %element_enter_4159, 0
br i1 %compare_zero_enter_4159, label %post_loop_4159, label %loop_body_4159
loop_body_4159:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4159
; >ENTER_INC_PTR 1467
%dataptr_1467 = load i32, i32* %dataptr_addr
%inc_dataptr_1467 = add i32 %dataptr_1467, 8
store i32 %inc_dataptr_1467, i32* %dataptr_addr
; <ENTER_INC_PTR 1467
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4156
%dataptr_enter_4156 = load i32, i32* %dataptr_addr
%element_addr_enter_4156 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4156
%element_enter_4156 = load i8, i8* %element_addr_enter_4156
%compare_zero_enter_4156 = icmp eq i8 %element_enter_4156, 0
br i1 %compare_zero_enter_4156, label %post_loop_4156, label %loop_body_4156
loop_body_4156:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4156
; >ENTER_DEC_DATA 1476
%dataptr_1476 = load i32, i32* %dataptr_addr
%element_addr_1476 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1476
%element_1476 = load i8, i8* %element_addr_1476
%sub_element_1476 = sub i8 %element_1476, 1
store i8 %sub_element_1476, i8* %element_addr_1476
; <ENTER_DEC_DATA 1476
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4156
%dataptr_leave_4156 = load i32, i32* %dataptr_addr
%element_addr_leave_4156 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4156
%element_leave_4156 = load i8, i8* %element_addr_leave_4156
%compare_zero_leave_4156 = icmp ne i8 %element_leave_4156, 0
br i1 %compare_zero_leave_4156, label %loop_body_4156, label %post_loop_4156
post_loop_4156:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4156
; >ENTER_INC_PTR 1478
%dataptr_1478 = load i32, i32* %dataptr_addr
%inc_dataptr_1478 = add i32 %dataptr_1478, 1
store i32 %inc_dataptr_1478, i32* %dataptr_addr
; <ENTER_INC_PTR 1478
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4157
%dataptr_enter_4157 = load i32, i32* %dataptr_addr
%element_addr_enter_4157 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4157
%element_enter_4157 = load i8, i8* %element_addr_enter_4157
%compare_zero_enter_4157 = icmp eq i8 %element_enter_4157, 0
br i1 %compare_zero_enter_4157, label %post_loop_4157, label %loop_body_4157
loop_body_4157:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4157
; >ENTER_DEC_DATA 1480
%dataptr_1480 = load i32, i32* %dataptr_addr
%element_addr_1480 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1480
%element_1480 = load i8, i8* %element_addr_1480
%sub_element_1480 = sub i8 %element_1480, 1
store i8 %sub_element_1480, i8* %element_addr_1480
; <ENTER_DEC_DATA 1480
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4157
%dataptr_leave_4157 = load i32, i32* %dataptr_addr
%element_addr_leave_4157 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4157
%element_leave_4157 = load i8, i8* %element_addr_leave_4157
%compare_zero_leave_4157 = icmp ne i8 %element_leave_4157, 0
br i1 %compare_zero_leave_4157, label %loop_body_4157, label %post_loop_4157
post_loop_4157:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4157
; >ENTER_DEC_PTR 1482
%dataptr_1482 = load i32, i32* %dataptr_addr
%dec_dataptr_1482 = sub i32 %dataptr_1482, 5
store i32 %dec_dataptr_1482, i32* %dataptr_addr
; <ENTER_DEC_PTR 1482
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4158
%dataptr_enter_4158 = load i32, i32* %dataptr_addr
%element_addr_enter_4158 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4158
%element_enter_4158 = load i8, i8* %element_addr_enter_4158
%compare_zero_enter_4158 = icmp eq i8 %element_enter_4158, 0
br i1 %compare_zero_enter_4158, label %post_loop_4158, label %loop_body_4158
loop_body_4158:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4158
; >ENTER_DEC_DATA 1488
%dataptr_1488 = load i32, i32* %dataptr_addr
%element_addr_1488 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1488
%element_1488 = load i8, i8* %element_addr_1488
%sub_element_1488 = sub i8 %element_1488, 1
store i8 %sub_element_1488, i8* %element_addr_1488
; <ENTER_DEC_DATA 1488
; >ENTER_INC_PTR 1489
%dataptr_1489 = load i32, i32* %dataptr_addr
%inc_dataptr_1489 = add i32 %dataptr_1489, 3
store i32 %inc_dataptr_1489, i32* %dataptr_addr
; <ENTER_INC_PTR 1489
; >ENTER_INC_DATA 1492
%dataptr_1492 = load i32, i32* %dataptr_addr
%element_addr_1492 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1492
%element_1492 = load i8, i8* %element_addr_1492
%inc_element_1492 = add i8 %element_1492, 1
store i8 %inc_element_1492, i8* %element_addr_1492
; <ENTER_INC_DATA 1492
; >ENTER_INC_PTR 1493
%dataptr_1493 = load i32, i32* %dataptr_addr
%inc_dataptr_1493 = add i32 %dataptr_1493, 1
store i32 %inc_dataptr_1493, i32* %dataptr_addr
; <ENTER_INC_PTR 1493
; >ENTER_INC_DATA 1494
%dataptr_1494 = load i32, i32* %dataptr_addr
%element_addr_1494 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1494
%element_1494 = load i8, i8* %element_addr_1494
%inc_element_1494 = add i8 %element_1494, 1
store i8 %inc_element_1494, i8* %element_addr_1494
; <ENTER_INC_DATA 1494
; >ENTER_DEC_PTR 1495
%dataptr_1495 = load i32, i32* %dataptr_addr
%dec_dataptr_1495 = sub i32 %dataptr_1495, 4
store i32 %dec_dataptr_1495, i32* %dataptr_addr
; <ENTER_DEC_PTR 1495
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4158
%dataptr_leave_4158 = load i32, i32* %dataptr_addr
%element_addr_leave_4158 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4158
%element_leave_4158 = load i8, i8* %element_addr_leave_4158
%compare_zero_leave_4158 = icmp ne i8 %element_leave_4158, 0
br i1 %compare_zero_leave_4158, label %loop_body_4158, label %post_loop_4158
post_loop_4158:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4158
; >ENTER_INC_PTR 1500
%dataptr_1500 = load i32, i32* %dataptr_addr
%inc_dataptr_1500 = add i32 %dataptr_1500, 6
store i32 %inc_dataptr_1500, i32* %dataptr_addr
; <ENTER_INC_PTR 1500
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4159
%dataptr_leave_4159 = load i32, i32* %dataptr_addr
%element_addr_leave_4159 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4159
%element_leave_4159 = load i8, i8* %element_addr_leave_4159
%compare_zero_leave_4159 = icmp ne i8 %element_leave_4159, 0
br i1 %compare_zero_leave_4159, label %loop_body_4159, label %post_loop_4159
post_loop_4159:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4159
; >ENTER_DEC_PTR 1507
%dataptr_1507 = load i32, i32* %dataptr_addr
%dec_dataptr_1507 = sub i32 %dataptr_1507, 10
store i32 %dec_dataptr_1507, i32* %dataptr_addr
; <ENTER_DEC_PTR 1507
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4162
%dataptr_enter_4162 = load i32, i32* %dataptr_addr
%element_addr_enter_4162 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4162
%element_enter_4162 = load i8, i8* %element_addr_enter_4162
%compare_zero_enter_4162 = icmp eq i8 %element_enter_4162, 0
br i1 %compare_zero_enter_4162, label %post_loop_4162, label %loop_body_4162
loop_body_4162:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4162
; >ENTER_INC_PTR 1519
%dataptr_1519 = load i32, i32* %dataptr_addr
%inc_dataptr_1519 = add i32 %dataptr_1519, 8
store i32 %inc_dataptr_1519, i32* %dataptr_addr
; <ENTER_INC_PTR 1519
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4160
%dataptr_enter_4160 = load i32, i32* %dataptr_addr
%element_addr_enter_4160 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4160
%element_enter_4160 = load i8, i8* %element_addr_enter_4160
%compare_zero_enter_4160 = icmp eq i8 %element_enter_4160, 0
br i1 %compare_zero_enter_4160, label %post_loop_4160, label %loop_body_4160
loop_body_4160:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4160
; >ENTER_DEC_DATA 1528
%dataptr_1528 = load i32, i32* %dataptr_addr
%element_addr_1528 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1528
%element_1528 = load i8, i8* %element_addr_1528
%sub_element_1528 = sub i8 %element_1528, 1
store i8 %sub_element_1528, i8* %element_addr_1528
; <ENTER_DEC_DATA 1528
; >ENTER_DEC_PTR 1529
%dataptr_1529 = load i32, i32* %dataptr_addr
%dec_dataptr_1529 = sub i32 %dataptr_1529, 4
store i32 %dec_dataptr_1529, i32* %dataptr_addr
; <ENTER_DEC_PTR 1529
; >ENTER_INC_DATA 1533
%dataptr_1533 = load i32, i32* %dataptr_addr
%element_addr_1533 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1533
%element_1533 = load i8, i8* %element_addr_1533
%inc_element_1533 = add i8 %element_1533, 1
store i8 %inc_element_1533, i8* %element_addr_1533
; <ENTER_INC_DATA 1533
; >ENTER_INC_PTR 1534
%dataptr_1534 = load i32, i32* %dataptr_addr
%inc_dataptr_1534 = add i32 %dataptr_1534, 4
store i32 %inc_dataptr_1534, i32* %dataptr_addr
; <ENTER_INC_PTR 1534
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4160
%dataptr_leave_4160 = load i32, i32* %dataptr_addr
%element_addr_leave_4160 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4160
%element_leave_4160 = load i8, i8* %element_addr_leave_4160
%compare_zero_leave_4160 = icmp ne i8 %element_leave_4160, 0
br i1 %compare_zero_leave_4160, label %loop_body_4160, label %post_loop_4160
post_loop_4160:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4160
; >ENTER_DEC_PTR 1539
%dataptr_1539 = load i32, i32* %dataptr_addr
%dec_dataptr_1539 = sub i32 %dataptr_1539, 3
store i32 %dec_dataptr_1539, i32* %dataptr_addr
; <ENTER_DEC_PTR 1539
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4161
%dataptr_enter_4161 = load i32, i32* %dataptr_addr
%element_addr_enter_4161 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4161
%element_enter_4161 = load i8, i8* %element_addr_enter_4161
%compare_zero_enter_4161 = icmp eq i8 %element_enter_4161, 0
br i1 %compare_zero_enter_4161, label %post_loop_4161, label %loop_body_4161
loop_body_4161:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4161
; >ENTER_DEC_DATA 1543
%dataptr_1543 = load i32, i32* %dataptr_addr
%element_addr_1543 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1543
%element_1543 = load i8, i8* %element_addr_1543
%sub_element_1543 = sub i8 %element_1543, 1
store i8 %sub_element_1543, i8* %element_addr_1543
; <ENTER_DEC_DATA 1543
; >ENTER_INC_PTR 1544
%dataptr_1544 = load i32, i32* %dataptr_addr
%inc_dataptr_1544 = add i32 %dataptr_1544, 3
store i32 %inc_dataptr_1544, i32* %dataptr_addr
; <ENTER_INC_PTR 1544
; >ENTER_INC_DATA 1547
%dataptr_1547 = load i32, i32* %dataptr_addr
%element_addr_1547 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1547
%element_1547 = load i8, i8* %element_addr_1547
%inc_element_1547 = add i8 %element_1547, 1
store i8 %inc_element_1547, i8* %element_addr_1547
; <ENTER_INC_DATA 1547
; >ENTER_INC_PTR 1548
%dataptr_1548 = load i32, i32* %dataptr_addr
%inc_dataptr_1548 = add i32 %dataptr_1548, 1
store i32 %inc_dataptr_1548, i32* %dataptr_addr
; <ENTER_INC_PTR 1548
; >ENTER_INC_DATA 1549
%dataptr_1549 = load i32, i32* %dataptr_addr
%element_addr_1549 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1549
%element_1549 = load i8, i8* %element_addr_1549
%inc_element_1549 = add i8 %element_1549, 1
store i8 %inc_element_1549, i8* %element_addr_1549
; <ENTER_INC_DATA 1549
; >ENTER_DEC_PTR 1550
%dataptr_1550 = load i32, i32* %dataptr_addr
%dec_dataptr_1550 = sub i32 %dataptr_1550, 4
store i32 %dec_dataptr_1550, i32* %dataptr_addr
; <ENTER_DEC_PTR 1550
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4161
%dataptr_leave_4161 = load i32, i32* %dataptr_addr
%element_addr_leave_4161 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4161
%element_leave_4161 = load i8, i8* %element_addr_leave_4161
%compare_zero_leave_4161 = icmp ne i8 %element_leave_4161, 0
br i1 %compare_zero_leave_4161, label %loop_body_4161, label %post_loop_4161
post_loop_4161:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4161
; >ENTER_DEC_PTR 1555
%dataptr_1555 = load i32, i32* %dataptr_addr
%dec_dataptr_1555 = sub i32 %dataptr_1555, 15
store i32 %dec_dataptr_1555, i32* %dataptr_addr
; <ENTER_DEC_PTR 1555
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4162
%dataptr_leave_4162 = load i32, i32* %dataptr_addr
%element_addr_leave_4162 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4162
%element_leave_4162 = load i8, i8* %element_addr_leave_4162
%compare_zero_leave_4162 = icmp ne i8 %element_leave_4162, 0
br i1 %compare_zero_leave_4162, label %loop_body_4162, label %post_loop_4162
post_loop_4162:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4162
; >ENTER_INC_PTR 1571
%dataptr_1571 = load i32, i32* %dataptr_addr
%inc_dataptr_1571 = add i32 %dataptr_1571, 10
store i32 %inc_dataptr_1571, i32* %dataptr_addr
; <ENTER_INC_PTR 1571
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4164
%dataptr_enter_4164 = load i32, i32* %dataptr_addr
%element_addr_enter_4164 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4164
%element_enter_4164 = load i8, i8* %element_addr_enter_4164
%compare_zero_enter_4164 = icmp eq i8 %element_enter_4164, 0
br i1 %compare_zero_enter_4164, label %post_loop_4164, label %loop_body_4164
loop_body_4164:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4164
; >ENTER_INC_PTR 1583
%dataptr_1583 = load i32, i32* %dataptr_addr
%inc_dataptr_1583 = add i32 %dataptr_1583, 9
store i32 %inc_dataptr_1583, i32* %dataptr_addr
; <ENTER_INC_PTR 1583
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4163
%dataptr_enter_4163 = load i32, i32* %dataptr_addr
%element_addr_enter_4163 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4163
%element_enter_4163 = load i8, i8* %element_addr_enter_4163
%compare_zero_enter_4163 = icmp eq i8 %element_enter_4163, 0
br i1 %compare_zero_enter_4163, label %post_loop_4163, label %loop_body_4163
loop_body_4163:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4163
; >ENTER_DEC_DATA 1593
%dataptr_1593 = load i32, i32* %dataptr_addr
%element_addr_1593 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1593
%element_1593 = load i8, i8* %element_addr_1593
%sub_element_1593 = sub i8 %element_1593, 1
store i8 %sub_element_1593, i8* %element_addr_1593
; <ENTER_DEC_DATA 1593
; >ENTER_DEC_PTR 1594
%dataptr_1594 = load i32, i32* %dataptr_addr
%dec_dataptr_1594 = sub i32 %dataptr_1594, 4
store i32 %dec_dataptr_1594, i32* %dataptr_addr
; <ENTER_DEC_PTR 1594
; >ENTER_INC_DATA 1598
%dataptr_1598 = load i32, i32* %dataptr_addr
%element_addr_1598 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1598
%element_1598 = load i8, i8* %element_addr_1598
%inc_element_1598 = add i8 %element_1598, 1
store i8 %inc_element_1598, i8* %element_addr_1598
; <ENTER_INC_DATA 1598
; >ENTER_INC_PTR 1599
%dataptr_1599 = load i32, i32* %dataptr_addr
%inc_dataptr_1599 = add i32 %dataptr_1599, 4
store i32 %inc_dataptr_1599, i32* %dataptr_addr
; <ENTER_INC_PTR 1599
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4163
%dataptr_leave_4163 = load i32, i32* %dataptr_addr
%element_addr_leave_4163 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4163
%element_leave_4163 = load i8, i8* %element_addr_leave_4163
%compare_zero_leave_4163 = icmp ne i8 %element_leave_4163, 0
br i1 %compare_zero_leave_4163, label %loop_body_4163, label %post_loop_4163
post_loop_4163:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4163
; >ENTER_INC_PTR 1604
%dataptr_1604 = load i32, i32* %dataptr_addr
%inc_dataptr_1604 = add i32 %dataptr_1604, 1
store i32 %inc_dataptr_1604, i32* %dataptr_addr
; <ENTER_INC_PTR 1604
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4164
%dataptr_leave_4164 = load i32, i32* %dataptr_addr
%element_addr_leave_4164 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4164
%element_leave_4164 = load i8, i8* %element_addr_leave_4164
%compare_zero_leave_4164 = icmp ne i8 %element_leave_4164, 0
br i1 %compare_zero_leave_4164, label %loop_body_4164, label %post_loop_4164
post_loop_4164:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4164
; >ENTER_DEC_PTR 1606
%dataptr_1606 = load i32, i32* %dataptr_addr
%dec_dataptr_1606 = sub i32 %dataptr_1606, 10
store i32 %dec_dataptr_1606, i32* %dataptr_addr
; <ENTER_DEC_PTR 1606
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4166
%dataptr_enter_4166 = load i32, i32* %dataptr_addr
%element_addr_enter_4166 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4166
%element_enter_4166 = load i8, i8* %element_addr_enter_4166
%compare_zero_enter_4166 = icmp eq i8 %element_enter_4166, 0
br i1 %compare_zero_enter_4166, label %post_loop_4166, label %loop_body_4166
loop_body_4166:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4166
; >ENTER_INC_PTR 1618
%dataptr_1618 = load i32, i32* %dataptr_addr
%inc_dataptr_1618 = add i32 %dataptr_1618, 8
store i32 %inc_dataptr_1618, i32* %dataptr_addr
; <ENTER_INC_PTR 1618
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4165
%dataptr_enter_4165 = load i32, i32* %dataptr_addr
%element_addr_enter_4165 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4165
%element_enter_4165 = load i8, i8* %element_addr_enter_4165
%compare_zero_enter_4165 = icmp eq i8 %element_enter_4165, 0
br i1 %compare_zero_enter_4165, label %post_loop_4165, label %loop_body_4165
loop_body_4165:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4165
; >ENTER_DEC_DATA 1627
%dataptr_1627 = load i32, i32* %dataptr_addr
%element_addr_1627 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1627
%element_1627 = load i8, i8* %element_addr_1627
%sub_element_1627 = sub i8 %element_1627, 1
store i8 %sub_element_1627, i8* %element_addr_1627
; <ENTER_DEC_DATA 1627
; >ENTER_DEC_PTR 1628
%dataptr_1628 = load i32, i32* %dataptr_addr
%dec_dataptr_1628 = sub i32 %dataptr_1628, 1
store i32 %dec_dataptr_1628, i32* %dataptr_addr
; <ENTER_DEC_PTR 1628
; >ENTER_DEC_DATA 1629
%dataptr_1629 = load i32, i32* %dataptr_addr
%element_addr_1629 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1629
%element_1629 = load i8, i8* %element_addr_1629
%sub_element_1629 = sub i8 %element_1629, 1
store i8 %sub_element_1629, i8* %element_addr_1629
; <ENTER_DEC_DATA 1629
; >ENTER_INC_PTR 1630
%dataptr_1630 = load i32, i32* %dataptr_addr
%inc_dataptr_1630 = add i32 %dataptr_1630, 1
store i32 %inc_dataptr_1630, i32* %dataptr_addr
; <ENTER_INC_PTR 1630
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4165
%dataptr_leave_4165 = load i32, i32* %dataptr_addr
%element_addr_leave_4165 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4165
%element_leave_4165 = load i8, i8* %element_addr_leave_4165
%compare_zero_leave_4165 = icmp ne i8 %element_leave_4165, 0
br i1 %compare_zero_leave_4165, label %loop_body_4165, label %post_loop_4165
post_loop_4165:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4165
; >ENTER_DEC_PTR 1632
%dataptr_1632 = load i32, i32* %dataptr_addr
%dec_dataptr_1632 = sub i32 %dataptr_1632, 18
store i32 %dec_dataptr_1632, i32* %dataptr_addr
; <ENTER_DEC_PTR 1632
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4166
%dataptr_leave_4166 = load i32, i32* %dataptr_addr
%element_addr_leave_4166 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4166
%element_leave_4166 = load i8, i8* %element_addr_leave_4166
%compare_zero_leave_4166 = icmp ne i8 %element_leave_4166, 0
br i1 %compare_zero_leave_4166, label %loop_body_4166, label %post_loop_4166
post_loop_4166:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4166
; >ENTER_INC_PTR 1651
%dataptr_1651 = load i32, i32* %dataptr_addr
%inc_dataptr_1651 = add i32 %dataptr_1651, 10
store i32 %inc_dataptr_1651, i32* %dataptr_addr
; <ENTER_INC_PTR 1651
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4179
%dataptr_enter_4179 = load i32, i32* %dataptr_addr
%element_addr_enter_4179 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4179
%element_enter_4179 = load i8, i8* %element_addr_enter_4179
%compare_zero_enter_4179 = icmp eq i8 %element_enter_4179, 0
br i1 %compare_zero_enter_4179, label %post_loop_4179, label %loop_body_4179
loop_body_4179:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4179
; >ENTER_INC_PTR 1663
%dataptr_1663 = load i32, i32* %dataptr_addr
%inc_dataptr_1663 = add i32 %dataptr_1663, 7
store i32 %inc_dataptr_1663, i32* %dataptr_addr
; <ENTER_INC_PTR 1663
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4178
%dataptr_enter_4178 = load i32, i32* %dataptr_addr
%element_addr_enter_4178 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4178
%element_enter_4178 = load i8, i8* %element_addr_enter_4178
%compare_zero_enter_4178 = icmp eq i8 %element_enter_4178, 0
br i1 %compare_zero_enter_4178, label %post_loop_4178, label %loop_body_4178
loop_body_4178:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4178
; >ENTER_DEC_DATA 1671
%dataptr_1671 = load i32, i32* %dataptr_addr
%element_addr_1671 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1671
%element_1671 = load i8, i8* %element_addr_1671
%sub_element_1671 = sub i8 %element_1671, 1
store i8 %sub_element_1671, i8* %element_addr_1671
; <ENTER_DEC_DATA 1671
; >ENTER_INC_PTR 1672
%dataptr_1672 = load i32, i32* %dataptr_addr
%inc_dataptr_1672 = add i32 %dataptr_1672, 1
store i32 %inc_dataptr_1672, i32* %dataptr_addr
; <ENTER_INC_PTR 1672
; >ENTER_INC_DATA 1673
%dataptr_1673 = load i32, i32* %dataptr_addr
%element_addr_1673 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1673
%element_1673 = load i8, i8* %element_addr_1673
%inc_element_1673 = add i8 %element_1673, 1
store i8 %inc_element_1673, i8* %element_addr_1673
; <ENTER_INC_DATA 1673
; >ENTER_DEC_PTR 1674
%dataptr_1674 = load i32, i32* %dataptr_addr
%dec_dataptr_1674 = sub i32 %dataptr_1674, 1
store i32 %dec_dataptr_1674, i32* %dataptr_addr
; <ENTER_DEC_PTR 1674
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4177
%dataptr_enter_4177 = load i32, i32* %dataptr_addr
%element_addr_enter_4177 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4177
%element_enter_4177 = load i8, i8* %element_addr_enter_4177
%compare_zero_enter_4177 = icmp eq i8 %element_enter_4177, 0
br i1 %compare_zero_enter_4177, label %post_loop_4177, label %loop_body_4177
loop_body_4177:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4177
; >ENTER_DEC_DATA 1676
%dataptr_1676 = load i32, i32* %dataptr_addr
%element_addr_1676 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1676
%element_1676 = load i8, i8* %element_addr_1676
%sub_element_1676 = sub i8 %element_1676, 1
store i8 %sub_element_1676, i8* %element_addr_1676
; <ENTER_DEC_DATA 1676
; >ENTER_INC_PTR 1677
%dataptr_1677 = load i32, i32* %dataptr_addr
%inc_dataptr_1677 = add i32 %dataptr_1677, 1
store i32 %inc_dataptr_1677, i32* %dataptr_addr
; <ENTER_INC_PTR 1677
; >ENTER_INC_DATA 1678
%dataptr_1678 = load i32, i32* %dataptr_addr
%element_addr_1678 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1678
%element_1678 = load i8, i8* %element_addr_1678
%inc_element_1678 = add i8 %element_1678, 1
store i8 %inc_element_1678, i8* %element_addr_1678
; <ENTER_INC_DATA 1678
; >ENTER_DEC_PTR 1679
%dataptr_1679 = load i32, i32* %dataptr_addr
%dec_dataptr_1679 = sub i32 %dataptr_1679, 1
store i32 %dec_dataptr_1679, i32* %dataptr_addr
; <ENTER_DEC_PTR 1679
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4176
%dataptr_enter_4176 = load i32, i32* %dataptr_addr
%element_addr_enter_4176 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4176
%element_enter_4176 = load i8, i8* %element_addr_enter_4176
%compare_zero_enter_4176 = icmp eq i8 %element_enter_4176, 0
br i1 %compare_zero_enter_4176, label %post_loop_4176, label %loop_body_4176
loop_body_4176:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4176
; >ENTER_DEC_DATA 1681
%dataptr_1681 = load i32, i32* %dataptr_addr
%element_addr_1681 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1681
%element_1681 = load i8, i8* %element_addr_1681
%sub_element_1681 = sub i8 %element_1681, 1
store i8 %sub_element_1681, i8* %element_addr_1681
; <ENTER_DEC_DATA 1681
; >ENTER_INC_PTR 1682
%dataptr_1682 = load i32, i32* %dataptr_addr
%inc_dataptr_1682 = add i32 %dataptr_1682, 1
store i32 %inc_dataptr_1682, i32* %dataptr_addr
; <ENTER_INC_PTR 1682
; >ENTER_INC_DATA 1683
%dataptr_1683 = load i32, i32* %dataptr_addr
%element_addr_1683 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1683
%element_1683 = load i8, i8* %element_addr_1683
%inc_element_1683 = add i8 %element_1683, 1
store i8 %inc_element_1683, i8* %element_addr_1683
; <ENTER_INC_DATA 1683
; >ENTER_DEC_PTR 1684
%dataptr_1684 = load i32, i32* %dataptr_addr
%dec_dataptr_1684 = sub i32 %dataptr_1684, 1
store i32 %dec_dataptr_1684, i32* %dataptr_addr
; <ENTER_DEC_PTR 1684
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4175
%dataptr_enter_4175 = load i32, i32* %dataptr_addr
%element_addr_enter_4175 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4175
%element_enter_4175 = load i8, i8* %element_addr_enter_4175
%compare_zero_enter_4175 = icmp eq i8 %element_enter_4175, 0
br i1 %compare_zero_enter_4175, label %post_loop_4175, label %loop_body_4175
loop_body_4175:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4175
; >ENTER_DEC_DATA 1686
%dataptr_1686 = load i32, i32* %dataptr_addr
%element_addr_1686 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1686
%element_1686 = load i8, i8* %element_addr_1686
%sub_element_1686 = sub i8 %element_1686, 1
store i8 %sub_element_1686, i8* %element_addr_1686
; <ENTER_DEC_DATA 1686
; >ENTER_INC_PTR 1687
%dataptr_1687 = load i32, i32* %dataptr_addr
%inc_dataptr_1687 = add i32 %dataptr_1687, 1
store i32 %inc_dataptr_1687, i32* %dataptr_addr
; <ENTER_INC_PTR 1687
; >ENTER_INC_DATA 1688
%dataptr_1688 = load i32, i32* %dataptr_addr
%element_addr_1688 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1688
%element_1688 = load i8, i8* %element_addr_1688
%inc_element_1688 = add i8 %element_1688, 1
store i8 %inc_element_1688, i8* %element_addr_1688
; <ENTER_INC_DATA 1688
; >ENTER_DEC_PTR 1689
%dataptr_1689 = load i32, i32* %dataptr_addr
%dec_dataptr_1689 = sub i32 %dataptr_1689, 1
store i32 %dec_dataptr_1689, i32* %dataptr_addr
; <ENTER_DEC_PTR 1689
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4174
%dataptr_enter_4174 = load i32, i32* %dataptr_addr
%element_addr_enter_4174 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4174
%element_enter_4174 = load i8, i8* %element_addr_enter_4174
%compare_zero_enter_4174 = icmp eq i8 %element_enter_4174, 0
br i1 %compare_zero_enter_4174, label %post_loop_4174, label %loop_body_4174
loop_body_4174:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4174
; >ENTER_DEC_DATA 1691
%dataptr_1691 = load i32, i32* %dataptr_addr
%element_addr_1691 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1691
%element_1691 = load i8, i8* %element_addr_1691
%sub_element_1691 = sub i8 %element_1691, 1
store i8 %sub_element_1691, i8* %element_addr_1691
; <ENTER_DEC_DATA 1691
; >ENTER_INC_PTR 1692
%dataptr_1692 = load i32, i32* %dataptr_addr
%inc_dataptr_1692 = add i32 %dataptr_1692, 1
store i32 %inc_dataptr_1692, i32* %dataptr_addr
; <ENTER_INC_PTR 1692
; >ENTER_INC_DATA 1693
%dataptr_1693 = load i32, i32* %dataptr_addr
%element_addr_1693 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1693
%element_1693 = load i8, i8* %element_addr_1693
%inc_element_1693 = add i8 %element_1693, 1
store i8 %inc_element_1693, i8* %element_addr_1693
; <ENTER_INC_DATA 1693
; >ENTER_DEC_PTR 1694
%dataptr_1694 = load i32, i32* %dataptr_addr
%dec_dataptr_1694 = sub i32 %dataptr_1694, 1
store i32 %dec_dataptr_1694, i32* %dataptr_addr
; <ENTER_DEC_PTR 1694
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4173
%dataptr_enter_4173 = load i32, i32* %dataptr_addr
%element_addr_enter_4173 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4173
%element_enter_4173 = load i8, i8* %element_addr_enter_4173
%compare_zero_enter_4173 = icmp eq i8 %element_enter_4173, 0
br i1 %compare_zero_enter_4173, label %post_loop_4173, label %loop_body_4173
loop_body_4173:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4173
; >ENTER_DEC_DATA 1696
%dataptr_1696 = load i32, i32* %dataptr_addr
%element_addr_1696 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1696
%element_1696 = load i8, i8* %element_addr_1696
%sub_element_1696 = sub i8 %element_1696, 1
store i8 %sub_element_1696, i8* %element_addr_1696
; <ENTER_DEC_DATA 1696
; >ENTER_INC_PTR 1697
%dataptr_1697 = load i32, i32* %dataptr_addr
%inc_dataptr_1697 = add i32 %dataptr_1697, 1
store i32 %inc_dataptr_1697, i32* %dataptr_addr
; <ENTER_INC_PTR 1697
; >ENTER_INC_DATA 1698
%dataptr_1698 = load i32, i32* %dataptr_addr
%element_addr_1698 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1698
%element_1698 = load i8, i8* %element_addr_1698
%inc_element_1698 = add i8 %element_1698, 1
store i8 %inc_element_1698, i8* %element_addr_1698
; <ENTER_INC_DATA 1698
; >ENTER_DEC_PTR 1699
%dataptr_1699 = load i32, i32* %dataptr_addr
%dec_dataptr_1699 = sub i32 %dataptr_1699, 1
store i32 %dec_dataptr_1699, i32* %dataptr_addr
; <ENTER_DEC_PTR 1699
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4172
%dataptr_enter_4172 = load i32, i32* %dataptr_addr
%element_addr_enter_4172 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4172
%element_enter_4172 = load i8, i8* %element_addr_enter_4172
%compare_zero_enter_4172 = icmp eq i8 %element_enter_4172, 0
br i1 %compare_zero_enter_4172, label %post_loop_4172, label %loop_body_4172
loop_body_4172:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4172
; >ENTER_DEC_DATA 1701
%dataptr_1701 = load i32, i32* %dataptr_addr
%element_addr_1701 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1701
%element_1701 = load i8, i8* %element_addr_1701
%sub_element_1701 = sub i8 %element_1701, 1
store i8 %sub_element_1701, i8* %element_addr_1701
; <ENTER_DEC_DATA 1701
; >ENTER_INC_PTR 1702
%dataptr_1702 = load i32, i32* %dataptr_addr
%inc_dataptr_1702 = add i32 %dataptr_1702, 1
store i32 %inc_dataptr_1702, i32* %dataptr_addr
; <ENTER_INC_PTR 1702
; >ENTER_INC_DATA 1703
%dataptr_1703 = load i32, i32* %dataptr_addr
%element_addr_1703 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1703
%element_1703 = load i8, i8* %element_addr_1703
%inc_element_1703 = add i8 %element_1703, 1
store i8 %inc_element_1703, i8* %element_addr_1703
; <ENTER_INC_DATA 1703
; >ENTER_DEC_PTR 1704
%dataptr_1704 = load i32, i32* %dataptr_addr
%dec_dataptr_1704 = sub i32 %dataptr_1704, 1
store i32 %dec_dataptr_1704, i32* %dataptr_addr
; <ENTER_DEC_PTR 1704
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4171
%dataptr_enter_4171 = load i32, i32* %dataptr_addr
%element_addr_enter_4171 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4171
%element_enter_4171 = load i8, i8* %element_addr_enter_4171
%compare_zero_enter_4171 = icmp eq i8 %element_enter_4171, 0
br i1 %compare_zero_enter_4171, label %post_loop_4171, label %loop_body_4171
loop_body_4171:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4171
; >ENTER_DEC_DATA 1706
%dataptr_1706 = load i32, i32* %dataptr_addr
%element_addr_1706 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1706
%element_1706 = load i8, i8* %element_addr_1706
%sub_element_1706 = sub i8 %element_1706, 1
store i8 %sub_element_1706, i8* %element_addr_1706
; <ENTER_DEC_DATA 1706
; >ENTER_INC_PTR 1707
%dataptr_1707 = load i32, i32* %dataptr_addr
%inc_dataptr_1707 = add i32 %dataptr_1707, 1
store i32 %inc_dataptr_1707, i32* %dataptr_addr
; <ENTER_INC_PTR 1707
; >ENTER_INC_DATA 1708
%dataptr_1708 = load i32, i32* %dataptr_addr
%element_addr_1708 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1708
%element_1708 = load i8, i8* %element_addr_1708
%inc_element_1708 = add i8 %element_1708, 1
store i8 %inc_element_1708, i8* %element_addr_1708
; <ENTER_INC_DATA 1708
; >ENTER_DEC_PTR 1709
%dataptr_1709 = load i32, i32* %dataptr_addr
%dec_dataptr_1709 = sub i32 %dataptr_1709, 1
store i32 %dec_dataptr_1709, i32* %dataptr_addr
; <ENTER_DEC_PTR 1709
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4170
%dataptr_enter_4170 = load i32, i32* %dataptr_addr
%element_addr_enter_4170 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4170
%element_enter_4170 = load i8, i8* %element_addr_enter_4170
%compare_zero_enter_4170 = icmp eq i8 %element_enter_4170, 0
br i1 %compare_zero_enter_4170, label %post_loop_4170, label %loop_body_4170
loop_body_4170:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4170
; >ENTER_DEC_DATA 1711
%dataptr_1711 = load i32, i32* %dataptr_addr
%element_addr_1711 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1711
%element_1711 = load i8, i8* %element_addr_1711
%sub_element_1711 = sub i8 %element_1711, 1
store i8 %sub_element_1711, i8* %element_addr_1711
; <ENTER_DEC_DATA 1711
; >ENTER_INC_PTR 1712
%dataptr_1712 = load i32, i32* %dataptr_addr
%inc_dataptr_1712 = add i32 %dataptr_1712, 1
store i32 %inc_dataptr_1712, i32* %dataptr_addr
; <ENTER_INC_PTR 1712
; >ENTER_INC_DATA 1713
%dataptr_1713 = load i32, i32* %dataptr_addr
%element_addr_1713 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1713
%element_1713 = load i8, i8* %element_addr_1713
%inc_element_1713 = add i8 %element_1713, 1
store i8 %inc_element_1713, i8* %element_addr_1713
; <ENTER_INC_DATA 1713
; >ENTER_DEC_PTR 1714
%dataptr_1714 = load i32, i32* %dataptr_addr
%dec_dataptr_1714 = sub i32 %dataptr_1714, 1
store i32 %dec_dataptr_1714, i32* %dataptr_addr
; <ENTER_DEC_PTR 1714
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4169
%dataptr_enter_4169 = load i32, i32* %dataptr_addr
%element_addr_enter_4169 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4169
%element_enter_4169 = load i8, i8* %element_addr_enter_4169
%compare_zero_enter_4169 = icmp eq i8 %element_enter_4169, 0
br i1 %compare_zero_enter_4169, label %post_loop_4169, label %loop_body_4169
loop_body_4169:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4169
; >ENTER_DEC_DATA 1716
%dataptr_1716 = load i32, i32* %dataptr_addr
%element_addr_1716 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1716
%element_1716 = load i8, i8* %element_addr_1716
%sub_element_1716 = sub i8 %element_1716, 1
store i8 %sub_element_1716, i8* %element_addr_1716
; <ENTER_DEC_DATA 1716
; >ENTER_INC_PTR 1717
%dataptr_1717 = load i32, i32* %dataptr_addr
%inc_dataptr_1717 = add i32 %dataptr_1717, 1
store i32 %inc_dataptr_1717, i32* %dataptr_addr
; <ENTER_INC_PTR 1717
; >ENTER_INC_DATA 1718
%dataptr_1718 = load i32, i32* %dataptr_addr
%element_addr_1718 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1718
%element_1718 = load i8, i8* %element_addr_1718
%inc_element_1718 = add i8 %element_1718, 1
store i8 %inc_element_1718, i8* %element_addr_1718
; <ENTER_INC_DATA 1718
; >ENTER_DEC_PTR 1719
%dataptr_1719 = load i32, i32* %dataptr_addr
%dec_dataptr_1719 = sub i32 %dataptr_1719, 1
store i32 %dec_dataptr_1719, i32* %dataptr_addr
; <ENTER_DEC_PTR 1719
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4168
%dataptr_enter_4168 = load i32, i32* %dataptr_addr
%element_addr_enter_4168 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4168
%element_enter_4168 = load i8, i8* %element_addr_enter_4168
%compare_zero_enter_4168 = icmp eq i8 %element_enter_4168, 0
br i1 %compare_zero_enter_4168, label %post_loop_4168, label %loop_body_4168
loop_body_4168:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4168
; >ENTER_INC_DATA 1722
%dataptr_1722 = load i32, i32* %dataptr_addr
%element_addr_1722 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1722
%element_1722 = load i8, i8* %element_addr_1722
%inc_element_1722 = add i8 %element_1722, 10
store i8 %inc_element_1722, i8* %element_addr_1722
; <ENTER_INC_DATA 1722
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4167
%dataptr_enter_4167 = load i32, i32* %dataptr_addr
%element_addr_enter_4167 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4167
%element_enter_4167 = load i8, i8* %element_addr_enter_4167
%compare_zero_enter_4167 = icmp eq i8 %element_enter_4167, 0
br i1 %compare_zero_enter_4167, label %post_loop_4167, label %loop_body_4167
loop_body_4167:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4167
; >ENTER_INC_DATA 1733
%dataptr_1733 = load i32, i32* %dataptr_addr
%element_addr_1733 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1733
%element_1733 = load i8, i8* %element_addr_1733
%inc_element_1733 = add i8 %element_1733, 1
store i8 %inc_element_1733, i8* %element_addr_1733
; <ENTER_INC_DATA 1733
; >ENTER_INC_PTR 1734
%dataptr_1734 = load i32, i32* %dataptr_addr
%inc_dataptr_1734 = add i32 %dataptr_1734, 1
store i32 %inc_dataptr_1734, i32* %dataptr_addr
; <ENTER_INC_PTR 1734
; >ENTER_DEC_DATA 1735
%dataptr_1735 = load i32, i32* %dataptr_addr
%element_addr_1735 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1735
%element_1735 = load i8, i8* %element_addr_1735
%sub_element_1735 = sub i8 %element_1735, 1
store i8 %sub_element_1735, i8* %element_addr_1735
; <ENTER_DEC_DATA 1735
; >ENTER_DEC_PTR 1736
%dataptr_1736 = load i32, i32* %dataptr_addr
%dec_dataptr_1736 = sub i32 %dataptr_1736, 1
store i32 %dec_dataptr_1736, i32* %dataptr_addr
; <ENTER_DEC_PTR 1736
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4167
%dataptr_leave_4167 = load i32, i32* %dataptr_addr
%element_addr_leave_4167 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4167
%element_leave_4167 = load i8, i8* %element_addr_leave_4167
%compare_zero_leave_4167 = icmp ne i8 %element_leave_4167, 0
br i1 %compare_zero_leave_4167, label %loop_body_4167, label %post_loop_4167
post_loop_4167:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4167
; >ENTER_INC_PTR 1738
%dataptr_1738 = load i32, i32* %dataptr_addr
%inc_dataptr_1738 = add i32 %dataptr_1738, 10
store i32 %inc_dataptr_1738, i32* %dataptr_addr
; <ENTER_INC_PTR 1738
; >ENTER_DEC_DATA 1748
%dataptr_1748 = load i32, i32* %dataptr_addr
%element_addr_1748 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1748
%element_1748 = load i8, i8* %element_addr_1748
%sub_element_1748 = sub i8 %element_1748, 1
store i8 %sub_element_1748, i8* %element_addr_1748
; <ENTER_DEC_DATA 1748
; >ENTER_DEC_PTR 1749
%dataptr_1749 = load i32, i32* %dataptr_addr
%dec_dataptr_1749 = sub i32 %dataptr_1749, 10
store i32 %dec_dataptr_1749, i32* %dataptr_addr
; <ENTER_DEC_PTR 1749
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4168
%dataptr_leave_4168 = load i32, i32* %dataptr_addr
%element_addr_leave_4168 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4168
%element_leave_4168 = load i8, i8* %element_addr_leave_4168
%compare_zero_leave_4168 = icmp ne i8 %element_leave_4168, 0
br i1 %compare_zero_leave_4168, label %loop_body_4168, label %post_loop_4168
post_loop_4168:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4168
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4169
%dataptr_leave_4169 = load i32, i32* %dataptr_addr
%element_addr_leave_4169 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4169
%element_leave_4169 = load i8, i8* %element_addr_leave_4169
%compare_zero_leave_4169 = icmp ne i8 %element_leave_4169, 0
br i1 %compare_zero_leave_4169, label %loop_body_4169, label %post_loop_4169
post_loop_4169:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4169
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4170
%dataptr_leave_4170 = load i32, i32* %dataptr_addr
%element_addr_leave_4170 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4170
%element_leave_4170 = load i8, i8* %element_addr_leave_4170
%compare_zero_leave_4170 = icmp ne i8 %element_leave_4170, 0
br i1 %compare_zero_leave_4170, label %loop_body_4170, label %post_loop_4170
post_loop_4170:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4170
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4171
%dataptr_leave_4171 = load i32, i32* %dataptr_addr
%element_addr_leave_4171 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4171
%element_leave_4171 = load i8, i8* %element_addr_leave_4171
%compare_zero_leave_4171 = icmp ne i8 %element_leave_4171, 0
br i1 %compare_zero_leave_4171, label %loop_body_4171, label %post_loop_4171
post_loop_4171:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4171
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4172
%dataptr_leave_4172 = load i32, i32* %dataptr_addr
%element_addr_leave_4172 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4172
%element_leave_4172 = load i8, i8* %element_addr_leave_4172
%compare_zero_leave_4172 = icmp ne i8 %element_leave_4172, 0
br i1 %compare_zero_leave_4172, label %loop_body_4172, label %post_loop_4172
post_loop_4172:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4172
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4173
%dataptr_leave_4173 = load i32, i32* %dataptr_addr
%element_addr_leave_4173 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4173
%element_leave_4173 = load i8, i8* %element_addr_leave_4173
%compare_zero_leave_4173 = icmp ne i8 %element_leave_4173, 0
br i1 %compare_zero_leave_4173, label %loop_body_4173, label %post_loop_4173
post_loop_4173:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4173
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4174
%dataptr_leave_4174 = load i32, i32* %dataptr_addr
%element_addr_leave_4174 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4174
%element_leave_4174 = load i8, i8* %element_addr_leave_4174
%compare_zero_leave_4174 = icmp ne i8 %element_leave_4174, 0
br i1 %compare_zero_leave_4174, label %loop_body_4174, label %post_loop_4174
post_loop_4174:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4174
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4175
%dataptr_leave_4175 = load i32, i32* %dataptr_addr
%element_addr_leave_4175 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4175
%element_leave_4175 = load i8, i8* %element_addr_leave_4175
%compare_zero_leave_4175 = icmp ne i8 %element_leave_4175, 0
br i1 %compare_zero_leave_4175, label %loop_body_4175, label %post_loop_4175
post_loop_4175:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4175
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4176
%dataptr_leave_4176 = load i32, i32* %dataptr_addr
%element_addr_leave_4176 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4176
%element_leave_4176 = load i8, i8* %element_addr_leave_4176
%compare_zero_leave_4176 = icmp ne i8 %element_leave_4176, 0
br i1 %compare_zero_leave_4176, label %loop_body_4176, label %post_loop_4176
post_loop_4176:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4176
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4177
%dataptr_leave_4177 = load i32, i32* %dataptr_addr
%element_addr_leave_4177 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4177
%element_leave_4177 = load i8, i8* %element_addr_leave_4177
%compare_zero_leave_4177 = icmp ne i8 %element_leave_4177, 0
br i1 %compare_zero_leave_4177, label %loop_body_4177, label %post_loop_4177
post_loop_4177:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4177
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4178
%dataptr_leave_4178 = load i32, i32* %dataptr_addr
%element_addr_leave_4178 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4178
%element_leave_4178 = load i8, i8* %element_addr_leave_4178
%compare_zero_leave_4178 = icmp ne i8 %element_leave_4178, 0
br i1 %compare_zero_leave_4178, label %loop_body_4178, label %post_loop_4178
post_loop_4178:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4178
; >ENTER_INC_PTR 1770
%dataptr_1770 = load i32, i32* %dataptr_addr
%inc_dataptr_1770 = add i32 %dataptr_1770, 3
store i32 %inc_dataptr_1770, i32* %dataptr_addr
; <ENTER_INC_PTR 1770
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4179
%dataptr_leave_4179 = load i32, i32* %dataptr_addr
%element_addr_leave_4179 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4179
%element_leave_4179 = load i8, i8* %element_addr_leave_4179
%compare_zero_leave_4179 = icmp ne i8 %element_leave_4179, 0
br i1 %compare_zero_leave_4179, label %loop_body_4179, label %post_loop_4179
post_loop_4179:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4179
; >ENTER_INC_PTR 1775
%dataptr_1775 = load i32, i32* %dataptr_addr
%inc_dataptr_1775 = add i32 %dataptr_1775, 7
store i32 %inc_dataptr_1775, i32* %dataptr_addr
; <ENTER_INC_PTR 1775
; >ENTER_INC_DATA 1782
%dataptr_1782 = load i32, i32* %dataptr_addr
%element_addr_1782 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1782
%element_1782 = load i8, i8* %element_addr_1782
%inc_element_1782 = add i8 %element_1782, 1
store i8 %inc_element_1782, i8* %element_addr_1782
; <ENTER_INC_DATA 1782
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4201
%dataptr_enter_4201 = load i32, i32* %dataptr_addr
%element_addr_enter_4201 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4201
%element_enter_4201 = load i8, i8* %element_addr_enter_4201
%compare_zero_enter_4201 = icmp eq i8 %element_enter_4201, 0
br i1 %compare_zero_enter_4201, label %post_loop_4201, label %loop_body_4201
loop_body_4201:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4201
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4180
%dataptr_enter_4180 = load i32, i32* %dataptr_addr
%element_addr_enter_4180 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4180
%element_enter_4180 = load i8, i8* %element_addr_enter_4180
%compare_zero_enter_4180 = icmp eq i8 %element_enter_4180, 0
br i1 %compare_zero_enter_4180, label %post_loop_4180, label %loop_body_4180
loop_body_4180:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4180
; >ENTER_DEC_DATA 1787
%dataptr_1787 = load i32, i32* %dataptr_addr
%element_addr_1787 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1787
%element_1787 = load i8, i8* %element_addr_1787
%sub_element_1787 = sub i8 %element_1787, 1
store i8 %sub_element_1787, i8* %element_addr_1787
; <ENTER_DEC_DATA 1787
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4180
%dataptr_leave_4180 = load i32, i32* %dataptr_addr
%element_addr_leave_4180 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4180
%element_leave_4180 = load i8, i8* %element_addr_leave_4180
%compare_zero_leave_4180 = icmp ne i8 %element_leave_4180, 0
br i1 %compare_zero_leave_4180, label %loop_body_4180, label %post_loop_4180
post_loop_4180:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4180
; >ENTER_DEC_PTR 1789
%dataptr_1789 = load i32, i32* %dataptr_addr
%dec_dataptr_1789 = sub i32 %dataptr_1789, 17
store i32 %dec_dataptr_1789, i32* %dataptr_addr
; <ENTER_DEC_PTR 1789
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4184
%dataptr_enter_4184 = load i32, i32* %dataptr_addr
%element_addr_enter_4184 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4184
%element_enter_4184 = load i8, i8* %element_addr_enter_4184
%compare_zero_enter_4184 = icmp eq i8 %element_enter_4184, 0
br i1 %compare_zero_enter_4184, label %post_loop_4184, label %loop_body_4184
loop_body_4184:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4184
; >ENTER_INC_PTR 1808
%dataptr_1808 = load i32, i32* %dataptr_addr
%inc_dataptr_1808 = add i32 %dataptr_1808, 4
store i32 %inc_dataptr_1808, i32* %dataptr_addr
; <ENTER_INC_PTR 1808
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4181
%dataptr_enter_4181 = load i32, i32* %dataptr_addr
%element_addr_enter_4181 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4181
%element_enter_4181 = load i8, i8* %element_addr_enter_4181
%compare_zero_enter_4181 = icmp eq i8 %element_enter_4181, 0
br i1 %compare_zero_enter_4181, label %post_loop_4181, label %loop_body_4181
loop_body_4181:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4181
; >ENTER_DEC_DATA 1813
%dataptr_1813 = load i32, i32* %dataptr_addr
%element_addr_1813 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1813
%element_1813 = load i8, i8* %element_addr_1813
%sub_element_1813 = sub i8 %element_1813, 1
store i8 %sub_element_1813, i8* %element_addr_1813
; <ENTER_DEC_DATA 1813
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4181
%dataptr_leave_4181 = load i32, i32* %dataptr_addr
%element_addr_leave_4181 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4181
%element_leave_4181 = load i8, i8* %element_addr_leave_4181
%compare_zero_leave_4181 = icmp ne i8 %element_leave_4181, 0
br i1 %compare_zero_leave_4181, label %loop_body_4181, label %post_loop_4181
post_loop_4181:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4181
; >ENTER_INC_PTR 1815
%dataptr_1815 = load i32, i32* %dataptr_addr
%inc_dataptr_1815 = add i32 %dataptr_1815, 4
store i32 %inc_dataptr_1815, i32* %dataptr_addr
; <ENTER_INC_PTR 1815
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4182
%dataptr_enter_4182 = load i32, i32* %dataptr_addr
%element_addr_enter_4182 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4182
%element_enter_4182 = load i8, i8* %element_addr_enter_4182
%compare_zero_enter_4182 = icmp eq i8 %element_enter_4182, 0
br i1 %compare_zero_enter_4182, label %post_loop_4182, label %loop_body_4182
loop_body_4182:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4182
; >ENTER_DEC_DATA 1820
%dataptr_1820 = load i32, i32* %dataptr_addr
%element_addr_1820 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1820
%element_1820 = load i8, i8* %element_addr_1820
%sub_element_1820 = sub i8 %element_1820, 1
store i8 %sub_element_1820, i8* %element_addr_1820
; <ENTER_DEC_DATA 1820
; >ENTER_DEC_PTR 1821
%dataptr_1821 = load i32, i32* %dataptr_addr
%dec_dataptr_1821 = sub i32 %dataptr_1821, 4
store i32 %dec_dataptr_1821, i32* %dataptr_addr
; <ENTER_DEC_PTR 1821
; >ENTER_INC_DATA 1825
%dataptr_1825 = load i32, i32* %dataptr_addr
%element_addr_1825 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1825
%element_1825 = load i8, i8* %element_addr_1825
%inc_element_1825 = add i8 %element_1825, 1
store i8 %inc_element_1825, i8* %element_addr_1825
; <ENTER_INC_DATA 1825
; >ENTER_INC_PTR 1826
%dataptr_1826 = load i32, i32* %dataptr_addr
%inc_dataptr_1826 = add i32 %dataptr_1826, 4
store i32 %inc_dataptr_1826, i32* %dataptr_addr
; <ENTER_INC_PTR 1826
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4182
%dataptr_leave_4182 = load i32, i32* %dataptr_addr
%element_addr_leave_4182 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4182
%element_leave_4182 = load i8, i8* %element_addr_leave_4182
%compare_zero_leave_4182 = icmp ne i8 %element_leave_4182, 0
br i1 %compare_zero_leave_4182, label %loop_body_4182, label %post_loop_4182
post_loop_4182:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4182
; >ENTER_DEC_PTR 1831
%dataptr_1831 = load i32, i32* %dataptr_addr
%dec_dataptr_1831 = sub i32 %dataptr_1831, 2
store i32 %dec_dataptr_1831, i32* %dataptr_addr
; <ENTER_DEC_PTR 1831
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4183
%dataptr_enter_4183 = load i32, i32* %dataptr_addr
%element_addr_enter_4183 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4183
%element_enter_4183 = load i8, i8* %element_addr_enter_4183
%compare_zero_enter_4183 = icmp eq i8 %element_enter_4183, 0
br i1 %compare_zero_enter_4183, label %post_loop_4183, label %loop_body_4183
loop_body_4183:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4183
; >ENTER_DEC_DATA 1834
%dataptr_1834 = load i32, i32* %dataptr_addr
%element_addr_1834 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1834
%element_1834 = load i8, i8* %element_addr_1834
%sub_element_1834 = sub i8 %element_1834, 1
store i8 %sub_element_1834, i8* %element_addr_1834
; <ENTER_DEC_DATA 1834
; >ENTER_INC_PTR 1835
%dataptr_1835 = load i32, i32* %dataptr_addr
%inc_dataptr_1835 = add i32 %dataptr_1835, 2
store i32 %inc_dataptr_1835, i32* %dataptr_addr
; <ENTER_INC_PTR 1835
; >ENTER_INC_DATA 1837
%dataptr_1837 = load i32, i32* %dataptr_addr
%element_addr_1837 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1837
%element_1837 = load i8, i8* %element_addr_1837
%inc_element_1837 = add i8 %element_1837, 1
store i8 %inc_element_1837, i8* %element_addr_1837
; <ENTER_INC_DATA 1837
; >ENTER_DEC_PTR 1838
%dataptr_1838 = load i32, i32* %dataptr_addr
%dec_dataptr_1838 = sub i32 %dataptr_1838, 2
store i32 %dec_dataptr_1838, i32* %dataptr_addr
; <ENTER_DEC_PTR 1838
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4183
%dataptr_leave_4183 = load i32, i32* %dataptr_addr
%element_addr_leave_4183 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4183
%element_leave_4183 = load i8, i8* %element_addr_leave_4183
%compare_zero_leave_4183 = icmp ne i8 %element_leave_4183, 0
br i1 %compare_zero_leave_4183, label %loop_body_4183, label %post_loop_4183
post_loop_4183:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4183
; >ENTER_DEC_PTR 1841
%dataptr_1841 = load i32, i32* %dataptr_addr
%dec_dataptr_1841 = sub i32 %dataptr_1841, 16
store i32 %dec_dataptr_1841, i32* %dataptr_addr
; <ENTER_DEC_PTR 1841
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4184
%dataptr_leave_4184 = load i32, i32* %dataptr_addr
%element_addr_leave_4184 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4184
%element_leave_4184 = load i8, i8* %element_addr_leave_4184
%compare_zero_leave_4184 = icmp ne i8 %element_leave_4184, 0
br i1 %compare_zero_leave_4184, label %loop_body_4184, label %post_loop_4184
post_loop_4184:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4184
; >ENTER_INC_PTR 1858
%dataptr_1858 = load i32, i32* %dataptr_addr
%inc_dataptr_1858 = add i32 %dataptr_1858, 10
store i32 %inc_dataptr_1858, i32* %dataptr_addr
; <ENTER_INC_PTR 1858
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4186
%dataptr_enter_4186 = load i32, i32* %dataptr_addr
%element_addr_enter_4186 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4186
%element_enter_4186 = load i8, i8* %element_addr_enter_4186
%compare_zero_enter_4186 = icmp eq i8 %element_enter_4186, 0
br i1 %compare_zero_enter_4186, label %post_loop_4186, label %loop_body_4186
loop_body_4186:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4186
; >ENTER_INC_PTR 1870
%dataptr_1870 = load i32, i32* %dataptr_addr
%inc_dataptr_1870 = add i32 %dataptr_1870, 8
store i32 %inc_dataptr_1870, i32* %dataptr_addr
; <ENTER_INC_PTR 1870
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4185
%dataptr_enter_4185 = load i32, i32* %dataptr_addr
%element_addr_enter_4185 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4185
%element_enter_4185 = load i8, i8* %element_addr_enter_4185
%compare_zero_enter_4185 = icmp eq i8 %element_enter_4185, 0
br i1 %compare_zero_enter_4185, label %post_loop_4185, label %loop_body_4185
loop_body_4185:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4185
; >ENTER_DEC_DATA 1879
%dataptr_1879 = load i32, i32* %dataptr_addr
%element_addr_1879 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1879
%element_1879 = load i8, i8* %element_addr_1879
%sub_element_1879 = sub i8 %element_1879, 1
store i8 %sub_element_1879, i8* %element_addr_1879
; <ENTER_DEC_DATA 1879
; >ENTER_INC_PTR 1880
%dataptr_1880 = load i32, i32* %dataptr_addr
%inc_dataptr_1880 = add i32 %dataptr_1880, 1
store i32 %inc_dataptr_1880, i32* %dataptr_addr
; <ENTER_INC_PTR 1880
; >ENTER_INC_DATA 1881
%dataptr_1881 = load i32, i32* %dataptr_addr
%element_addr_1881 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1881
%element_1881 = load i8, i8* %element_addr_1881
%inc_element_1881 = add i8 %element_1881, 1
store i8 %inc_element_1881, i8* %element_addr_1881
; <ENTER_INC_DATA 1881
; >ENTER_DEC_PTR 1882
%dataptr_1882 = load i32, i32* %dataptr_addr
%dec_dataptr_1882 = sub i32 %dataptr_1882, 3
store i32 %dec_dataptr_1882, i32* %dataptr_addr
; <ENTER_DEC_PTR 1882
; >ENTER_INC_DATA 1885
%dataptr_1885 = load i32, i32* %dataptr_addr
%element_addr_1885 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1885
%element_1885 = load i8, i8* %element_addr_1885
%inc_element_1885 = add i8 %element_1885, 1
store i8 %inc_element_1885, i8* %element_addr_1885
; <ENTER_INC_DATA 1885
; >ENTER_INC_PTR 1886
%dataptr_1886 = load i32, i32* %dataptr_addr
%inc_dataptr_1886 = add i32 %dataptr_1886, 2
store i32 %inc_dataptr_1886, i32* %dataptr_addr
; <ENTER_INC_PTR 1886
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4185
%dataptr_leave_4185 = load i32, i32* %dataptr_addr
%element_addr_leave_4185 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4185
%element_leave_4185 = load i8, i8* %element_addr_leave_4185
%compare_zero_leave_4185 = icmp ne i8 %element_leave_4185, 0
br i1 %compare_zero_leave_4185, label %loop_body_4185, label %post_loop_4185
post_loop_4185:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4185
; >ENTER_INC_PTR 1889
%dataptr_1889 = load i32, i32* %dataptr_addr
%inc_dataptr_1889 = add i32 %dataptr_1889, 2
store i32 %inc_dataptr_1889, i32* %dataptr_addr
; <ENTER_INC_PTR 1889
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4186
%dataptr_leave_4186 = load i32, i32* %dataptr_addr
%element_addr_leave_4186 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4186
%element_leave_4186 = load i8, i8* %element_addr_leave_4186
%compare_zero_leave_4186 = icmp ne i8 %element_leave_4186, 0
br i1 %compare_zero_leave_4186, label %loop_body_4186, label %post_loop_4186
post_loop_4186:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4186
; >ENTER_DEC_PTR 1892
%dataptr_1892 = load i32, i32* %dataptr_addr
%dec_dataptr_1892 = sub i32 %dataptr_1892, 10
store i32 %dec_dataptr_1892, i32* %dataptr_addr
; <ENTER_DEC_PTR 1892
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4188
%dataptr_enter_4188 = load i32, i32* %dataptr_addr
%element_addr_enter_4188 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4188
%element_enter_4188 = load i8, i8* %element_addr_enter_4188
%compare_zero_enter_4188 = icmp eq i8 %element_enter_4188, 0
br i1 %compare_zero_enter_4188, label %post_loop_4188, label %loop_body_4188
loop_body_4188:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4188
; >ENTER_INC_PTR 1904
%dataptr_1904 = load i32, i32* %dataptr_addr
%inc_dataptr_1904 = add i32 %dataptr_1904, 3
store i32 %inc_dataptr_1904, i32* %dataptr_addr
; <ENTER_INC_PTR 1904
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4187
%dataptr_enter_4187 = load i32, i32* %dataptr_addr
%element_addr_enter_4187 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4187
%element_enter_4187 = load i8, i8* %element_addr_enter_4187
%compare_zero_enter_4187 = icmp eq i8 %element_enter_4187, 0
br i1 %compare_zero_enter_4187, label %post_loop_4187, label %loop_body_4187
loop_body_4187:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4187
; >ENTER_DEC_DATA 1908
%dataptr_1908 = load i32, i32* %dataptr_addr
%element_addr_1908 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1908
%element_1908 = load i8, i8* %element_addr_1908
%sub_element_1908 = sub i8 %element_1908, 1
store i8 %sub_element_1908, i8* %element_addr_1908
; <ENTER_DEC_DATA 1908
; >ENTER_INC_PTR 1909
%dataptr_1909 = load i32, i32* %dataptr_addr
%inc_dataptr_1909 = add i32 %dataptr_1909, 6
store i32 %inc_dataptr_1909, i32* %dataptr_addr
; <ENTER_INC_PTR 1909
; >ENTER_INC_DATA 1915
%dataptr_1915 = load i32, i32* %dataptr_addr
%element_addr_1915 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1915
%element_1915 = load i8, i8* %element_addr_1915
%inc_element_1915 = add i8 %element_1915, 1
store i8 %inc_element_1915, i8* %element_addr_1915
; <ENTER_INC_DATA 1915
; >ENTER_DEC_PTR 1916
%dataptr_1916 = load i32, i32* %dataptr_addr
%dec_dataptr_1916 = sub i32 %dataptr_1916, 6
store i32 %dec_dataptr_1916, i32* %dataptr_addr
; <ENTER_DEC_PTR 1916
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4187
%dataptr_leave_4187 = load i32, i32* %dataptr_addr
%element_addr_leave_4187 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4187
%element_leave_4187 = load i8, i8* %element_addr_leave_4187
%compare_zero_leave_4187 = icmp ne i8 %element_leave_4187, 0
br i1 %compare_zero_leave_4187, label %loop_body_4187, label %post_loop_4187
post_loop_4187:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4187
; >ENTER_DEC_PTR 1923
%dataptr_1923 = load i32, i32* %dataptr_addr
%dec_dataptr_1923 = sub i32 %dataptr_1923, 13
store i32 %dec_dataptr_1923, i32* %dataptr_addr
; <ENTER_DEC_PTR 1923
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4188
%dataptr_leave_4188 = load i32, i32* %dataptr_addr
%element_addr_leave_4188 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4188
%element_leave_4188 = load i8, i8* %element_addr_leave_4188
%compare_zero_leave_4188 = icmp ne i8 %element_leave_4188, 0
br i1 %compare_zero_leave_4188, label %loop_body_4188, label %post_loop_4188
post_loop_4188:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4188
; >ENTER_INC_PTR 1937
%dataptr_1937 = load i32, i32* %dataptr_addr
%inc_dataptr_1937 = add i32 %dataptr_1937, 10
store i32 %inc_dataptr_1937, i32* %dataptr_addr
; <ENTER_INC_PTR 1937
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4200
%dataptr_enter_4200 = load i32, i32* %dataptr_addr
%element_addr_enter_4200 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4200
%element_enter_4200 = load i8, i8* %element_addr_enter_4200
%compare_zero_enter_4200 = icmp eq i8 %element_enter_4200, 0
br i1 %compare_zero_enter_4200, label %post_loop_4200, label %loop_body_4200
loop_body_4200:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4200
; >ENTER_INC_PTR 1949
%dataptr_1949 = load i32, i32* %dataptr_addr
%inc_dataptr_1949 = add i32 %dataptr_1949, 9
store i32 %inc_dataptr_1949, i32* %dataptr_addr
; <ENTER_INC_PTR 1949
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4199
%dataptr_enter_4199 = load i32, i32* %dataptr_addr
%element_addr_enter_4199 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4199
%element_enter_4199 = load i8, i8* %element_addr_enter_4199
%compare_zero_enter_4199 = icmp eq i8 %element_enter_4199, 0
br i1 %compare_zero_enter_4199, label %post_loop_4199, label %loop_body_4199
loop_body_4199:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4199
; >ENTER_DEC_DATA 1959
%dataptr_1959 = load i32, i32* %dataptr_addr
%element_addr_1959 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1959
%element_1959 = load i8, i8* %element_addr_1959
%sub_element_1959 = sub i8 %element_1959, 1
store i8 %sub_element_1959, i8* %element_addr_1959
; <ENTER_DEC_DATA 1959
; >ENTER_DEC_PTR 1960
%dataptr_1960 = load i32, i32* %dataptr_addr
%dec_dataptr_1960 = sub i32 %dataptr_1960, 6
store i32 %dec_dataptr_1960, i32* %dataptr_addr
; <ENTER_DEC_PTR 1960
; >ENTER_INC_DATA 1966
%dataptr_1966 = load i32, i32* %dataptr_addr
%element_addr_1966 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1966
%element_1966 = load i8, i8* %element_addr_1966
%inc_element_1966 = add i8 %element_1966, 1
store i8 %inc_element_1966, i8* %element_addr_1966
; <ENTER_INC_DATA 1966
; >ENTER_INC_PTR 1967
%dataptr_1967 = load i32, i32* %dataptr_addr
%inc_dataptr_1967 = add i32 %dataptr_1967, 6
store i32 %inc_dataptr_1967, i32* %dataptr_addr
; <ENTER_INC_PTR 1967
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4198
%dataptr_enter_4198 = load i32, i32* %dataptr_addr
%element_addr_enter_4198 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4198
%element_enter_4198 = load i8, i8* %element_addr_enter_4198
%compare_zero_enter_4198 = icmp eq i8 %element_enter_4198, 0
br i1 %compare_zero_enter_4198, label %post_loop_4198, label %loop_body_4198
loop_body_4198:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4198
; >ENTER_DEC_DATA 1974
%dataptr_1974 = load i32, i32* %dataptr_addr
%element_addr_1974 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1974
%element_1974 = load i8, i8* %element_addr_1974
%sub_element_1974 = sub i8 %element_1974, 1
store i8 %sub_element_1974, i8* %element_addr_1974
; <ENTER_DEC_DATA 1974
; >ENTER_DEC_PTR 1975
%dataptr_1975 = load i32, i32* %dataptr_addr
%dec_dataptr_1975 = sub i32 %dataptr_1975, 6
store i32 %dec_dataptr_1975, i32* %dataptr_addr
; <ENTER_DEC_PTR 1975
; >ENTER_INC_DATA 1981
%dataptr_1981 = load i32, i32* %dataptr_addr
%element_addr_1981 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1981
%element_1981 = load i8, i8* %element_addr_1981
%inc_element_1981 = add i8 %element_1981, 1
store i8 %inc_element_1981, i8* %element_addr_1981
; <ENTER_INC_DATA 1981
; >ENTER_INC_PTR 1982
%dataptr_1982 = load i32, i32* %dataptr_addr
%inc_dataptr_1982 = add i32 %dataptr_1982, 6
store i32 %inc_dataptr_1982, i32* %dataptr_addr
; <ENTER_INC_PTR 1982
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4197
%dataptr_enter_4197 = load i32, i32* %dataptr_addr
%element_addr_enter_4197 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4197
%element_enter_4197 = load i8, i8* %element_addr_enter_4197
%compare_zero_enter_4197 = icmp eq i8 %element_enter_4197, 0
br i1 %compare_zero_enter_4197, label %post_loop_4197, label %loop_body_4197
loop_body_4197:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4197
; >ENTER_DEC_DATA 1990
%dataptr_1990 = load i32, i32* %dataptr_addr
%element_addr_1990 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1990
%element_1990 = load i8, i8* %element_addr_1990
%sub_element_1990 = sub i8 %element_1990, 1
store i8 %sub_element_1990, i8* %element_addr_1990
; <ENTER_DEC_DATA 1990
; >ENTER_DEC_PTR 1991
%dataptr_1991 = load i32, i32* %dataptr_addr
%dec_dataptr_1991 = sub i32 %dataptr_1991, 6
store i32 %dec_dataptr_1991, i32* %dataptr_addr
; <ENTER_DEC_PTR 1991
; >ENTER_INC_DATA 1997
%dataptr_1997 = load i32, i32* %dataptr_addr
%element_addr_1997 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_1997
%element_1997 = load i8, i8* %element_addr_1997
%inc_element_1997 = add i8 %element_1997, 1
store i8 %inc_element_1997, i8* %element_addr_1997
; <ENTER_INC_DATA 1997
; >ENTER_INC_PTR 1998
%dataptr_1998 = load i32, i32* %dataptr_addr
%inc_dataptr_1998 = add i32 %dataptr_1998, 6
store i32 %inc_dataptr_1998, i32* %dataptr_addr
; <ENTER_INC_PTR 1998
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4196
%dataptr_enter_4196 = load i32, i32* %dataptr_addr
%element_addr_enter_4196 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4196
%element_enter_4196 = load i8, i8* %element_addr_enter_4196
%compare_zero_enter_4196 = icmp eq i8 %element_enter_4196, 0
br i1 %compare_zero_enter_4196, label %post_loop_4196, label %loop_body_4196
loop_body_4196:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4196
; >ENTER_DEC_DATA 2005
%dataptr_2005 = load i32, i32* %dataptr_addr
%element_addr_2005 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2005
%element_2005 = load i8, i8* %element_addr_2005
%sub_element_2005 = sub i8 %element_2005, 1
store i8 %sub_element_2005, i8* %element_addr_2005
; <ENTER_DEC_DATA 2005
; >ENTER_DEC_PTR 2006
%dataptr_2006 = load i32, i32* %dataptr_addr
%dec_dataptr_2006 = sub i32 %dataptr_2006, 6
store i32 %dec_dataptr_2006, i32* %dataptr_addr
; <ENTER_DEC_PTR 2006
; >ENTER_INC_DATA 2012
%dataptr_2012 = load i32, i32* %dataptr_addr
%element_addr_2012 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2012
%element_2012 = load i8, i8* %element_addr_2012
%inc_element_2012 = add i8 %element_2012, 1
store i8 %inc_element_2012, i8* %element_addr_2012
; <ENTER_INC_DATA 2012
; >ENTER_INC_PTR 2013
%dataptr_2013 = load i32, i32* %dataptr_addr
%inc_dataptr_2013 = add i32 %dataptr_2013, 6
store i32 %inc_dataptr_2013, i32* %dataptr_addr
; <ENTER_INC_PTR 2013
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4195
%dataptr_enter_4195 = load i32, i32* %dataptr_addr
%element_addr_enter_4195 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4195
%element_enter_4195 = load i8, i8* %element_addr_enter_4195
%compare_zero_enter_4195 = icmp eq i8 %element_enter_4195, 0
br i1 %compare_zero_enter_4195, label %post_loop_4195, label %loop_body_4195
loop_body_4195:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4195
; >ENTER_DEC_DATA 2021
%dataptr_2021 = load i32, i32* %dataptr_addr
%element_addr_2021 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2021
%element_2021 = load i8, i8* %element_addr_2021
%sub_element_2021 = sub i8 %element_2021, 1
store i8 %sub_element_2021, i8* %element_addr_2021
; <ENTER_DEC_DATA 2021
; >ENTER_DEC_PTR 2022
%dataptr_2022 = load i32, i32* %dataptr_addr
%dec_dataptr_2022 = sub i32 %dataptr_2022, 6
store i32 %dec_dataptr_2022, i32* %dataptr_addr
; <ENTER_DEC_PTR 2022
; >ENTER_INC_DATA 2028
%dataptr_2028 = load i32, i32* %dataptr_addr
%element_addr_2028 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2028
%element_2028 = load i8, i8* %element_addr_2028
%inc_element_2028 = add i8 %element_2028, 1
store i8 %inc_element_2028, i8* %element_addr_2028
; <ENTER_INC_DATA 2028
; >ENTER_INC_PTR 2029
%dataptr_2029 = load i32, i32* %dataptr_addr
%inc_dataptr_2029 = add i32 %dataptr_2029, 6
store i32 %inc_dataptr_2029, i32* %dataptr_addr
; <ENTER_INC_PTR 2029
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4194
%dataptr_enter_4194 = load i32, i32* %dataptr_addr
%element_addr_enter_4194 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4194
%element_enter_4194 = load i8, i8* %element_addr_enter_4194
%compare_zero_enter_4194 = icmp eq i8 %element_enter_4194, 0
br i1 %compare_zero_enter_4194, label %post_loop_4194, label %loop_body_4194
loop_body_4194:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4194
; >ENTER_DEC_DATA 2036
%dataptr_2036 = load i32, i32* %dataptr_addr
%element_addr_2036 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2036
%element_2036 = load i8, i8* %element_addr_2036
%sub_element_2036 = sub i8 %element_2036, 1
store i8 %sub_element_2036, i8* %element_addr_2036
; <ENTER_DEC_DATA 2036
; >ENTER_DEC_PTR 2037
%dataptr_2037 = load i32, i32* %dataptr_addr
%dec_dataptr_2037 = sub i32 %dataptr_2037, 6
store i32 %dec_dataptr_2037, i32* %dataptr_addr
; <ENTER_DEC_PTR 2037
; >ENTER_INC_DATA 2043
%dataptr_2043 = load i32, i32* %dataptr_addr
%element_addr_2043 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2043
%element_2043 = load i8, i8* %element_addr_2043
%inc_element_2043 = add i8 %element_2043, 1
store i8 %inc_element_2043, i8* %element_addr_2043
; <ENTER_INC_DATA 2043
; >ENTER_INC_PTR 2044
%dataptr_2044 = load i32, i32* %dataptr_addr
%inc_dataptr_2044 = add i32 %dataptr_2044, 6
store i32 %inc_dataptr_2044, i32* %dataptr_addr
; <ENTER_INC_PTR 2044
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4193
%dataptr_enter_4193 = load i32, i32* %dataptr_addr
%element_addr_enter_4193 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4193
%element_enter_4193 = load i8, i8* %element_addr_enter_4193
%compare_zero_enter_4193 = icmp eq i8 %element_enter_4193, 0
br i1 %compare_zero_enter_4193, label %post_loop_4193, label %loop_body_4193
loop_body_4193:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4193
; >ENTER_DEC_DATA 2052
%dataptr_2052 = load i32, i32* %dataptr_addr
%element_addr_2052 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2052
%element_2052 = load i8, i8* %element_addr_2052
%sub_element_2052 = sub i8 %element_2052, 1
store i8 %sub_element_2052, i8* %element_addr_2052
; <ENTER_DEC_DATA 2052
; >ENTER_DEC_PTR 2053
%dataptr_2053 = load i32, i32* %dataptr_addr
%dec_dataptr_2053 = sub i32 %dataptr_2053, 6
store i32 %dec_dataptr_2053, i32* %dataptr_addr
; <ENTER_DEC_PTR 2053
; >ENTER_INC_DATA 2059
%dataptr_2059 = load i32, i32* %dataptr_addr
%element_addr_2059 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2059
%element_2059 = load i8, i8* %element_addr_2059
%inc_element_2059 = add i8 %element_2059, 1
store i8 %inc_element_2059, i8* %element_addr_2059
; <ENTER_INC_DATA 2059
; >ENTER_INC_PTR 2060
%dataptr_2060 = load i32, i32* %dataptr_addr
%inc_dataptr_2060 = add i32 %dataptr_2060, 6
store i32 %inc_dataptr_2060, i32* %dataptr_addr
; <ENTER_INC_PTR 2060
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4192
%dataptr_enter_4192 = load i32, i32* %dataptr_addr
%element_addr_enter_4192 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4192
%element_enter_4192 = load i8, i8* %element_addr_enter_4192
%compare_zero_enter_4192 = icmp eq i8 %element_enter_4192, 0
br i1 %compare_zero_enter_4192, label %post_loop_4192, label %loop_body_4192
loop_body_4192:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4192
; >ENTER_DEC_DATA 2067
%dataptr_2067 = load i32, i32* %dataptr_addr
%element_addr_2067 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2067
%element_2067 = load i8, i8* %element_addr_2067
%sub_element_2067 = sub i8 %element_2067, 1
store i8 %sub_element_2067, i8* %element_addr_2067
; <ENTER_DEC_DATA 2067
; >ENTER_DEC_PTR 2068
%dataptr_2068 = load i32, i32* %dataptr_addr
%dec_dataptr_2068 = sub i32 %dataptr_2068, 6
store i32 %dec_dataptr_2068, i32* %dataptr_addr
; <ENTER_DEC_PTR 2068
; >ENTER_INC_DATA 2074
%dataptr_2074 = load i32, i32* %dataptr_addr
%element_addr_2074 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2074
%element_2074 = load i8, i8* %element_addr_2074
%inc_element_2074 = add i8 %element_2074, 1
store i8 %inc_element_2074, i8* %element_addr_2074
; <ENTER_INC_DATA 2074
; >ENTER_INC_PTR 2075
%dataptr_2075 = load i32, i32* %dataptr_addr
%inc_dataptr_2075 = add i32 %dataptr_2075, 6
store i32 %inc_dataptr_2075, i32* %dataptr_addr
; <ENTER_INC_PTR 2075
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4191
%dataptr_enter_4191 = load i32, i32* %dataptr_addr
%element_addr_enter_4191 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4191
%element_enter_4191 = load i8, i8* %element_addr_enter_4191
%compare_zero_enter_4191 = icmp eq i8 %element_enter_4191, 0
br i1 %compare_zero_enter_4191, label %post_loop_4191, label %loop_body_4191
loop_body_4191:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4191
; >ENTER_DEC_DATA 2083
%dataptr_2083 = load i32, i32* %dataptr_addr
%element_addr_2083 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2083
%element_2083 = load i8, i8* %element_addr_2083
%sub_element_2083 = sub i8 %element_2083, 1
store i8 %sub_element_2083, i8* %element_addr_2083
; <ENTER_DEC_DATA 2083
; >ENTER_DEC_PTR 2084
%dataptr_2084 = load i32, i32* %dataptr_addr
%dec_dataptr_2084 = sub i32 %dataptr_2084, 6
store i32 %dec_dataptr_2084, i32* %dataptr_addr
; <ENTER_DEC_PTR 2084
; >ENTER_INC_DATA 2090
%dataptr_2090 = load i32, i32* %dataptr_addr
%element_addr_2090 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2090
%element_2090 = load i8, i8* %element_addr_2090
%inc_element_2090 = add i8 %element_2090, 1
store i8 %inc_element_2090, i8* %element_addr_2090
; <ENTER_INC_DATA 2090
; >ENTER_INC_PTR 2091
%dataptr_2091 = load i32, i32* %dataptr_addr
%inc_dataptr_2091 = add i32 %dataptr_2091, 6
store i32 %inc_dataptr_2091, i32* %dataptr_addr
; <ENTER_INC_PTR 2091
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4190
%dataptr_enter_4190 = load i32, i32* %dataptr_addr
%element_addr_enter_4190 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4190
%element_enter_4190 = load i8, i8* %element_addr_enter_4190
%compare_zero_enter_4190 = icmp eq i8 %element_enter_4190, 0
br i1 %compare_zero_enter_4190, label %post_loop_4190, label %loop_body_4190
loop_body_4190:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4190
; >ENTER_DEC_DATA 2098
%dataptr_2098 = load i32, i32* %dataptr_addr
%element_addr_2098 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2098
%element_2098 = load i8, i8* %element_addr_2098
%sub_element_2098 = sub i8 %element_2098, 1
store i8 %sub_element_2098, i8* %element_addr_2098
; <ENTER_DEC_DATA 2098
; >ENTER_DEC_PTR 2099
%dataptr_2099 = load i32, i32* %dataptr_addr
%dec_dataptr_2099 = sub i32 %dataptr_2099, 6
store i32 %dec_dataptr_2099, i32* %dataptr_addr
; <ENTER_DEC_PTR 2099
; >ENTER_DEC_DATA 2105
%dataptr_2105 = load i32, i32* %dataptr_addr
%element_addr_2105 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2105
%element_2105 = load i8, i8* %element_addr_2105
%sub_element_2105 = sub i8 %element_2105, 9
store i8 %sub_element_2105, i8* %element_addr_2105
; <ENTER_DEC_DATA 2105
; >ENTER_INC_PTR 2114
%dataptr_2114 = load i32, i32* %dataptr_addr
%inc_dataptr_2114 = add i32 %dataptr_2114, 16
store i32 %inc_dataptr_2114, i32* %dataptr_addr
; <ENTER_INC_PTR 2114
; >ENTER_INC_DATA 2130
%dataptr_2130 = load i32, i32* %dataptr_addr
%element_addr_2130 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2130
%element_2130 = load i8, i8* %element_addr_2130
%inc_element_2130 = add i8 %element_2130, 1
store i8 %inc_element_2130, i8* %element_addr_2130
; <ENTER_INC_DATA 2130
; >ENTER_DEC_PTR 2131
%dataptr_2131 = load i32, i32* %dataptr_addr
%dec_dataptr_2131 = sub i32 %dataptr_2131, 10
store i32 %dec_dataptr_2131, i32* %dataptr_addr
; <ENTER_DEC_PTR 2131
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4189
%dataptr_enter_4189 = load i32, i32* %dataptr_addr
%element_addr_enter_4189 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4189
%element_enter_4189 = load i8, i8* %element_addr_enter_4189
%compare_zero_enter_4189 = icmp eq i8 %element_enter_4189, 0
br i1 %compare_zero_enter_4189, label %post_loop_4189, label %loop_body_4189
loop_body_4189:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4189
; >ENTER_DEC_DATA 2143
%dataptr_2143 = load i32, i32* %dataptr_addr
%element_addr_2143 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2143
%element_2143 = load i8, i8* %element_addr_2143
%sub_element_2143 = sub i8 %element_2143, 1
store i8 %sub_element_2143, i8* %element_addr_2143
; <ENTER_DEC_DATA 2143
; >ENTER_DEC_PTR 2144
%dataptr_2144 = load i32, i32* %dataptr_addr
%dec_dataptr_2144 = sub i32 %dataptr_2144, 6
store i32 %dec_dataptr_2144, i32* %dataptr_addr
; <ENTER_DEC_PTR 2144
; >ENTER_INC_DATA 2150
%dataptr_2150 = load i32, i32* %dataptr_addr
%element_addr_2150 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2150
%element_2150 = load i8, i8* %element_addr_2150
%inc_element_2150 = add i8 %element_2150, 1
store i8 %inc_element_2150, i8* %element_addr_2150
; <ENTER_INC_DATA 2150
; >ENTER_INC_PTR 2151
%dataptr_2151 = load i32, i32* %dataptr_addr
%inc_dataptr_2151 = add i32 %dataptr_2151, 6
store i32 %inc_dataptr_2151, i32* %dataptr_addr
; <ENTER_INC_PTR 2151
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4189
%dataptr_leave_4189 = load i32, i32* %dataptr_addr
%element_addr_leave_4189 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4189
%element_leave_4189 = load i8, i8* %element_addr_leave_4189
%compare_zero_leave_4189 = icmp ne i8 %element_leave_4189, 0
br i1 %compare_zero_leave_4189, label %loop_body_4189, label %post_loop_4189
post_loop_4189:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4189
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4190
%dataptr_leave_4190 = load i32, i32* %dataptr_addr
%element_addr_leave_4190 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4190
%element_leave_4190 = load i8, i8* %element_addr_leave_4190
%compare_zero_leave_4190 = icmp ne i8 %element_leave_4190, 0
br i1 %compare_zero_leave_4190, label %loop_body_4190, label %post_loop_4190
post_loop_4190:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4190
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4191
%dataptr_leave_4191 = load i32, i32* %dataptr_addr
%element_addr_leave_4191 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4191
%element_leave_4191 = load i8, i8* %element_addr_leave_4191
%compare_zero_leave_4191 = icmp ne i8 %element_leave_4191, 0
br i1 %compare_zero_leave_4191, label %loop_body_4191, label %post_loop_4191
post_loop_4191:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4191
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4192
%dataptr_leave_4192 = load i32, i32* %dataptr_addr
%element_addr_leave_4192 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4192
%element_leave_4192 = load i8, i8* %element_addr_leave_4192
%compare_zero_leave_4192 = icmp ne i8 %element_leave_4192, 0
br i1 %compare_zero_leave_4192, label %loop_body_4192, label %post_loop_4192
post_loop_4192:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4192
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4193
%dataptr_leave_4193 = load i32, i32* %dataptr_addr
%element_addr_leave_4193 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4193
%element_leave_4193 = load i8, i8* %element_addr_leave_4193
%compare_zero_leave_4193 = icmp ne i8 %element_leave_4193, 0
br i1 %compare_zero_leave_4193, label %loop_body_4193, label %post_loop_4193
post_loop_4193:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4193
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4194
%dataptr_leave_4194 = load i32, i32* %dataptr_addr
%element_addr_leave_4194 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4194
%element_leave_4194 = load i8, i8* %element_addr_leave_4194
%compare_zero_leave_4194 = icmp ne i8 %element_leave_4194, 0
br i1 %compare_zero_leave_4194, label %loop_body_4194, label %post_loop_4194
post_loop_4194:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4194
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4195
%dataptr_leave_4195 = load i32, i32* %dataptr_addr
%element_addr_leave_4195 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4195
%element_leave_4195 = load i8, i8* %element_addr_leave_4195
%compare_zero_leave_4195 = icmp ne i8 %element_leave_4195, 0
br i1 %compare_zero_leave_4195, label %loop_body_4195, label %post_loop_4195
post_loop_4195:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4195
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4196
%dataptr_leave_4196 = load i32, i32* %dataptr_addr
%element_addr_leave_4196 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4196
%element_leave_4196 = load i8, i8* %element_addr_leave_4196
%compare_zero_leave_4196 = icmp ne i8 %element_leave_4196, 0
br i1 %compare_zero_leave_4196, label %loop_body_4196, label %post_loop_4196
post_loop_4196:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4196
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4197
%dataptr_leave_4197 = load i32, i32* %dataptr_addr
%element_addr_leave_4197 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4197
%element_leave_4197 = load i8, i8* %element_addr_leave_4197
%compare_zero_leave_4197 = icmp ne i8 %element_leave_4197, 0
br i1 %compare_zero_leave_4197, label %loop_body_4197, label %post_loop_4197
post_loop_4197:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4197
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4198
%dataptr_leave_4198 = load i32, i32* %dataptr_addr
%element_addr_leave_4198 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4198
%element_leave_4198 = load i8, i8* %element_addr_leave_4198
%compare_zero_leave_4198 = icmp ne i8 %element_leave_4198, 0
br i1 %compare_zero_leave_4198, label %loop_body_4198, label %post_loop_4198
post_loop_4198:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4198
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4199
%dataptr_leave_4199 = load i32, i32* %dataptr_addr
%element_addr_leave_4199 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4199
%element_leave_4199 = load i8, i8* %element_addr_leave_4199
%compare_zero_leave_4199 = icmp ne i8 %element_leave_4199, 0
br i1 %compare_zero_leave_4199, label %loop_body_4199, label %post_loop_4199
post_loop_4199:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4199
; >ENTER_INC_PTR 2168
%dataptr_2168 = load i32, i32* %dataptr_addr
%inc_dataptr_2168 = add i32 %dataptr_2168, 1
store i32 %inc_dataptr_2168, i32* %dataptr_addr
; <ENTER_INC_PTR 2168
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4200
%dataptr_leave_4200 = load i32, i32* %dataptr_addr
%element_addr_leave_4200 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4200
%element_leave_4200 = load i8, i8* %element_addr_leave_4200
%compare_zero_leave_4200 = icmp ne i8 %element_leave_4200, 0
br i1 %compare_zero_leave_4200, label %loop_body_4200, label %post_loop_4200
post_loop_4200:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4200
; >ENTER_INC_PTR 2171
%dataptr_2171 = load i32, i32* %dataptr_addr
%inc_dataptr_2171 = add i32 %dataptr_2171, 7
store i32 %inc_dataptr_2171, i32* %dataptr_addr
; <ENTER_INC_PTR 2171
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4201
%dataptr_leave_4201 = load i32, i32* %dataptr_addr
%element_addr_leave_4201 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4201
%element_leave_4201 = load i8, i8* %element_addr_leave_4201
%compare_zero_leave_4201 = icmp ne i8 %element_leave_4201, 0
br i1 %compare_zero_leave_4201, label %loop_body_4201, label %post_loop_4201
post_loop_4201:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4201
; >ENTER_DEC_PTR 2181
%dataptr_2181 = load i32, i32* %dataptr_addr
%dec_dataptr_2181 = sub i32 %dataptr_2181, 17
store i32 %dec_dataptr_2181, i32* %dataptr_addr
; <ENTER_DEC_PTR 2181
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4202
%dataptr_enter_4202 = load i32, i32* %dataptr_addr
%element_addr_enter_4202 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4202
%element_enter_4202 = load i8, i8* %element_addr_enter_4202
%compare_zero_enter_4202 = icmp eq i8 %element_enter_4202, 0
br i1 %compare_zero_enter_4202, label %post_loop_4202, label %loop_body_4202
loop_body_4202:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4202
; >ENTER_DEC_PTR 2199
%dataptr_2199 = load i32, i32* %dataptr_addr
%dec_dataptr_2199 = sub i32 %dataptr_2199, 10
store i32 %dec_dataptr_2199, i32* %dataptr_addr
; <ENTER_DEC_PTR 2199
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4202
%dataptr_leave_4202 = load i32, i32* %dataptr_addr
%element_addr_leave_4202 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4202
%element_leave_4202 = load i8, i8* %element_addr_leave_4202
%compare_zero_leave_4202 = icmp ne i8 %element_leave_4202, 0
br i1 %compare_zero_leave_4202, label %loop_body_4202, label %post_loop_4202
post_loop_4202:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4202
; >ENTER_INC_PTR 2210
%dataptr_2210 = load i32, i32* %dataptr_addr
%inc_dataptr_2210 = add i32 %dataptr_2210, 10
store i32 %inc_dataptr_2210, i32* %dataptr_addr
; <ENTER_INC_PTR 2210
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4206
%dataptr_enter_4206 = load i32, i32* %dataptr_addr
%element_addr_enter_4206 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4206
%element_enter_4206 = load i8, i8* %element_addr_enter_4206
%compare_zero_enter_4206 = icmp eq i8 %element_enter_4206, 0
br i1 %compare_zero_enter_4206, label %post_loop_4206, label %loop_body_4206
loop_body_4206:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4206
; >ENTER_INC_PTR 2222
%dataptr_2222 = load i32, i32* %dataptr_addr
%inc_dataptr_2222 = add i32 %dataptr_2222, 8
store i32 %inc_dataptr_2222, i32* %dataptr_addr
; <ENTER_INC_PTR 2222
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4203
%dataptr_enter_4203 = load i32, i32* %dataptr_addr
%element_addr_enter_4203 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4203
%element_enter_4203 = load i8, i8* %element_addr_enter_4203
%compare_zero_enter_4203 = icmp eq i8 %element_enter_4203, 0
br i1 %compare_zero_enter_4203, label %post_loop_4203, label %loop_body_4203
loop_body_4203:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4203
; >ENTER_DEC_DATA 2231
%dataptr_2231 = load i32, i32* %dataptr_addr
%element_addr_2231 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2231
%element_2231 = load i8, i8* %element_addr_2231
%sub_element_2231 = sub i8 %element_2231, 1
store i8 %sub_element_2231, i8* %element_addr_2231
; <ENTER_DEC_DATA 2231
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4203
%dataptr_leave_4203 = load i32, i32* %dataptr_addr
%element_addr_leave_4203 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4203
%element_leave_4203 = load i8, i8* %element_addr_leave_4203
%compare_zero_leave_4203 = icmp ne i8 %element_leave_4203, 0
br i1 %compare_zero_leave_4203, label %loop_body_4203, label %post_loop_4203
post_loop_4203:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4203
; >ENTER_DEC_PTR 2233
%dataptr_2233 = load i32, i32* %dataptr_addr
%dec_dataptr_2233 = sub i32 %dataptr_2233, 2
store i32 %dec_dataptr_2233, i32* %dataptr_addr
; <ENTER_DEC_PTR 2233
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4204
%dataptr_enter_4204 = load i32, i32* %dataptr_addr
%element_addr_enter_4204 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4204
%element_enter_4204 = load i8, i8* %element_addr_enter_4204
%compare_zero_enter_4204 = icmp eq i8 %element_enter_4204, 0
br i1 %compare_zero_enter_4204, label %post_loop_4204, label %loop_body_4204
loop_body_4204:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4204
; >ENTER_DEC_DATA 2236
%dataptr_2236 = load i32, i32* %dataptr_addr
%element_addr_2236 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2236
%element_2236 = load i8, i8* %element_addr_2236
%sub_element_2236 = sub i8 %element_2236, 1
store i8 %sub_element_2236, i8* %element_addr_2236
; <ENTER_DEC_DATA 2236
; >ENTER_INC_PTR 2237
%dataptr_2237 = load i32, i32* %dataptr_addr
%inc_dataptr_2237 = add i32 %dataptr_2237, 1
store i32 %inc_dataptr_2237, i32* %dataptr_addr
; <ENTER_INC_PTR 2237
; >ENTER_INC_DATA 2238
%dataptr_2238 = load i32, i32* %dataptr_addr
%element_addr_2238 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2238
%element_2238 = load i8, i8* %element_addr_2238
%inc_element_2238 = add i8 %element_2238, 1
store i8 %inc_element_2238, i8* %element_addr_2238
; <ENTER_INC_DATA 2238
; >ENTER_DEC_PTR 2239
%dataptr_2239 = load i32, i32* %dataptr_addr
%dec_dataptr_2239 = sub i32 %dataptr_2239, 1
store i32 %dec_dataptr_2239, i32* %dataptr_addr
; <ENTER_DEC_PTR 2239
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4204
%dataptr_leave_4204 = load i32, i32* %dataptr_addr
%element_addr_leave_4204 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4204
%element_leave_4204 = load i8, i8* %element_addr_leave_4204
%compare_zero_leave_4204 = icmp ne i8 %element_leave_4204, 0
br i1 %compare_zero_leave_4204, label %loop_body_4204, label %post_loop_4204
post_loop_4204:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4204
; >ENTER_DEC_PTR 2241
%dataptr_2241 = load i32, i32* %dataptr_addr
%dec_dataptr_2241 = sub i32 %dataptr_2241, 1
store i32 %dec_dataptr_2241, i32* %dataptr_addr
; <ENTER_DEC_PTR 2241
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4205
%dataptr_enter_4205 = load i32, i32* %dataptr_addr
%element_addr_enter_4205 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4205
%element_enter_4205 = load i8, i8* %element_addr_enter_4205
%compare_zero_enter_4205 = icmp eq i8 %element_enter_4205, 0
br i1 %compare_zero_enter_4205, label %post_loop_4205, label %loop_body_4205
loop_body_4205:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4205
; >ENTER_DEC_DATA 2243
%dataptr_2243 = load i32, i32* %dataptr_addr
%element_addr_2243 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2243
%element_2243 = load i8, i8* %element_addr_2243
%sub_element_2243 = sub i8 %element_2243, 1
store i8 %sub_element_2243, i8* %element_addr_2243
; <ENTER_DEC_DATA 2243
; >ENTER_INC_PTR 2244
%dataptr_2244 = load i32, i32* %dataptr_addr
%inc_dataptr_2244 = add i32 %dataptr_2244, 3
store i32 %inc_dataptr_2244, i32* %dataptr_addr
; <ENTER_INC_PTR 2244
; >ENTER_INC_DATA 2247
%dataptr_2247 = load i32, i32* %dataptr_addr
%element_addr_2247 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2247
%element_2247 = load i8, i8* %element_addr_2247
%inc_element_2247 = add i8 %element_2247, 1
store i8 %inc_element_2247, i8* %element_addr_2247
; <ENTER_INC_DATA 2247
; >ENTER_DEC_PTR 2248
%dataptr_2248 = load i32, i32* %dataptr_addr
%dec_dataptr_2248 = sub i32 %dataptr_2248, 3
store i32 %dec_dataptr_2248, i32* %dataptr_addr
; <ENTER_DEC_PTR 2248
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4205
%dataptr_leave_4205 = load i32, i32* %dataptr_addr
%element_addr_leave_4205 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4205
%element_leave_4205 = load i8, i8* %element_addr_leave_4205
%compare_zero_leave_4205 = icmp ne i8 %element_leave_4205, 0
br i1 %compare_zero_leave_4205, label %loop_body_4205, label %post_loop_4205
post_loop_4205:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4205
; >ENTER_INC_PTR 2252
%dataptr_2252 = load i32, i32* %dataptr_addr
%inc_dataptr_2252 = add i32 %dataptr_2252, 5
store i32 %inc_dataptr_2252, i32* %dataptr_addr
; <ENTER_INC_PTR 2252
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4206
%dataptr_leave_4206 = load i32, i32* %dataptr_addr
%element_addr_leave_4206 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4206
%element_leave_4206 = load i8, i8* %element_addr_leave_4206
%compare_zero_leave_4206 = icmp ne i8 %element_leave_4206, 0
br i1 %compare_zero_leave_4206, label %loop_body_4206, label %post_loop_4206
post_loop_4206:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4206
; >ENTER_DEC_PTR 2258
%dataptr_2258 = load i32, i32* %dataptr_addr
%dec_dataptr_2258 = sub i32 %dataptr_2258, 10
store i32 %dec_dataptr_2258, i32* %dataptr_addr
; <ENTER_DEC_PTR 2258
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4217
%dataptr_enter_4217 = load i32, i32* %dataptr_addr
%element_addr_enter_4217 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4217
%element_enter_4217 = load i8, i8* %element_addr_enter_4217
%compare_zero_enter_4217 = icmp eq i8 %element_enter_4217, 0
br i1 %compare_zero_enter_4217, label %post_loop_4217, label %loop_body_4217
loop_body_4217:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4217
; >ENTER_INC_DATA 2270
%dataptr_2270 = load i32, i32* %dataptr_addr
%element_addr_2270 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2270
%element_2270 = load i8, i8* %element_addr_2270
%inc_element_2270 = add i8 %element_2270, 1
store i8 %inc_element_2270, i8* %element_addr_2270
; <ENTER_INC_DATA 2270
; >ENTER_INC_PTR 2271
%dataptr_2271 = load i32, i32* %dataptr_addr
%inc_dataptr_2271 = add i32 %dataptr_2271, 7
store i32 %inc_dataptr_2271, i32* %dataptr_addr
; <ENTER_INC_PTR 2271
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4215
%dataptr_enter_4215 = load i32, i32* %dataptr_addr
%element_addr_enter_4215 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4215
%element_enter_4215 = load i8, i8* %element_addr_enter_4215
%compare_zero_enter_4215 = icmp eq i8 %element_enter_4215, 0
br i1 %compare_zero_enter_4215, label %post_loop_4215, label %loop_body_4215
loop_body_4215:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4215
; >ENTER_DEC_DATA 2279
%dataptr_2279 = load i32, i32* %dataptr_addr
%element_addr_2279 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2279
%element_2279 = load i8, i8* %element_addr_2279
%sub_element_2279 = sub i8 %element_2279, 1
store i8 %sub_element_2279, i8* %element_addr_2279
; <ENTER_DEC_DATA 2279
; >ENTER_DEC_PTR 2280
%dataptr_2280 = load i32, i32* %dataptr_addr
%dec_dataptr_2280 = sub i32 %dataptr_2280, 7
store i32 %dec_dataptr_2280, i32* %dataptr_addr
; <ENTER_DEC_PTR 2280
; >ENTER_INC_DATA 2287
%dataptr_2287 = load i32, i32* %dataptr_addr
%element_addr_2287 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2287
%element_2287 = load i8, i8* %element_addr_2287
%inc_element_2287 = add i8 %element_2287, 1
store i8 %inc_element_2287, i8* %element_addr_2287
; <ENTER_INC_DATA 2287
; >ENTER_INC_PTR 2288
%dataptr_2288 = load i32, i32* %dataptr_addr
%inc_dataptr_2288 = add i32 %dataptr_2288, 7
store i32 %inc_dataptr_2288, i32* %dataptr_addr
; <ENTER_INC_PTR 2288
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4214
%dataptr_enter_4214 = load i32, i32* %dataptr_addr
%element_addr_enter_4214 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4214
%element_enter_4214 = load i8, i8* %element_addr_enter_4214
%compare_zero_enter_4214 = icmp eq i8 %element_enter_4214, 0
br i1 %compare_zero_enter_4214, label %post_loop_4214, label %loop_body_4214
loop_body_4214:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4214
; >ENTER_DEC_DATA 2296
%dataptr_2296 = load i32, i32* %dataptr_addr
%element_addr_2296 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2296
%element_2296 = load i8, i8* %element_addr_2296
%sub_element_2296 = sub i8 %element_2296, 1
store i8 %sub_element_2296, i8* %element_addr_2296
; <ENTER_DEC_DATA 2296
; >ENTER_DEC_PTR 2297
%dataptr_2297 = load i32, i32* %dataptr_addr
%dec_dataptr_2297 = sub i32 %dataptr_2297, 7
store i32 %dec_dataptr_2297, i32* %dataptr_addr
; <ENTER_DEC_PTR 2297
; >ENTER_DEC_DATA 2304
%dataptr_2304 = load i32, i32* %dataptr_addr
%element_addr_2304 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2304
%element_2304 = load i8, i8* %element_addr_2304
%sub_element_2304 = sub i8 %element_2304, 1
store i8 %sub_element_2304, i8* %element_addr_2304
; <ENTER_DEC_DATA 2304
; >ENTER_INC_PTR 2305
%dataptr_2305 = load i32, i32* %dataptr_addr
%inc_dataptr_2305 = add i32 %dataptr_2305, 6
store i32 %inc_dataptr_2305, i32* %dataptr_addr
; <ENTER_INC_PTR 2305
; >ENTER_INC_DATA 2311
%dataptr_2311 = load i32, i32* %dataptr_addr
%element_addr_2311 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2311
%element_2311 = load i8, i8* %element_addr_2311
%inc_element_2311 = add i8 %element_2311, 1
store i8 %inc_element_2311, i8* %element_addr_2311
; <ENTER_INC_DATA 2311
; >ENTER_INC_PTR 2312
%dataptr_2312 = load i32, i32* %dataptr_addr
%inc_dataptr_2312 = add i32 %dataptr_2312, 1
store i32 %inc_dataptr_2312, i32* %dataptr_addr
; <ENTER_INC_PTR 2312
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4213
%dataptr_enter_4213 = load i32, i32* %dataptr_addr
%element_addr_enter_4213 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4213
%element_enter_4213 = load i8, i8* %element_addr_enter_4213
%compare_zero_enter_4213 = icmp eq i8 %element_enter_4213, 0
br i1 %compare_zero_enter_4213, label %post_loop_4213, label %loop_body_4213
loop_body_4213:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4213
; >ENTER_DEC_DATA 2315
%dataptr_2315 = load i32, i32* %dataptr_addr
%element_addr_2315 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2315
%element_2315 = load i8, i8* %element_addr_2315
%sub_element_2315 = sub i8 %element_2315, 1
store i8 %sub_element_2315, i8* %element_addr_2315
; <ENTER_DEC_DATA 2315
; >ENTER_DEC_PTR 2316
%dataptr_2316 = load i32, i32* %dataptr_addr
%dec_dataptr_2316 = sub i32 %dataptr_2316, 7
store i32 %dec_dataptr_2316, i32* %dataptr_addr
; <ENTER_DEC_PTR 2316
; >ENTER_INC_DATA 2323
%dataptr_2323 = load i32, i32* %dataptr_addr
%element_addr_2323 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2323
%element_2323 = load i8, i8* %element_addr_2323
%inc_element_2323 = add i8 %element_2323, 1
store i8 %inc_element_2323, i8* %element_addr_2323
; <ENTER_INC_DATA 2323
; >ENTER_INC_PTR 2324
%dataptr_2324 = load i32, i32* %dataptr_addr
%inc_dataptr_2324 = add i32 %dataptr_2324, 7
store i32 %inc_dataptr_2324, i32* %dataptr_addr
; <ENTER_INC_PTR 2324
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4212
%dataptr_enter_4212 = load i32, i32* %dataptr_addr
%element_addr_enter_4212 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4212
%element_enter_4212 = load i8, i8* %element_addr_enter_4212
%compare_zero_enter_4212 = icmp eq i8 %element_enter_4212, 0
br i1 %compare_zero_enter_4212, label %post_loop_4212, label %loop_body_4212
loop_body_4212:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4212
; >ENTER_DEC_DATA 2332
%dataptr_2332 = load i32, i32* %dataptr_addr
%element_addr_2332 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2332
%element_2332 = load i8, i8* %element_addr_2332
%sub_element_2332 = sub i8 %element_2332, 1
store i8 %sub_element_2332, i8* %element_addr_2332
; <ENTER_DEC_DATA 2332
; >ENTER_DEC_PTR 2333
%dataptr_2333 = load i32, i32* %dataptr_addr
%dec_dataptr_2333 = sub i32 %dataptr_2333, 7
store i32 %dec_dataptr_2333, i32* %dataptr_addr
; <ENTER_DEC_PTR 2333
; >ENTER_DEC_DATA 2340
%dataptr_2340 = load i32, i32* %dataptr_addr
%element_addr_2340 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2340
%element_2340 = load i8, i8* %element_addr_2340
%sub_element_2340 = sub i8 %element_2340, 1
store i8 %sub_element_2340, i8* %element_addr_2340
; <ENTER_DEC_DATA 2340
; >ENTER_INC_PTR 2341
%dataptr_2341 = load i32, i32* %dataptr_addr
%inc_dataptr_2341 = add i32 %dataptr_2341, 6
store i32 %inc_dataptr_2341, i32* %dataptr_addr
; <ENTER_INC_PTR 2341
; >ENTER_INC_DATA 2347
%dataptr_2347 = load i32, i32* %dataptr_addr
%element_addr_2347 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2347
%element_2347 = load i8, i8* %element_addr_2347
%inc_element_2347 = add i8 %element_2347, 1
store i8 %inc_element_2347, i8* %element_addr_2347
; <ENTER_INC_DATA 2347
; >ENTER_INC_PTR 2348
%dataptr_2348 = load i32, i32* %dataptr_addr
%inc_dataptr_2348 = add i32 %dataptr_2348, 1
store i32 %inc_dataptr_2348, i32* %dataptr_addr
; <ENTER_INC_PTR 2348
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4211
%dataptr_enter_4211 = load i32, i32* %dataptr_addr
%element_addr_enter_4211 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4211
%element_enter_4211 = load i8, i8* %element_addr_enter_4211
%compare_zero_enter_4211 = icmp eq i8 %element_enter_4211, 0
br i1 %compare_zero_enter_4211, label %post_loop_4211, label %loop_body_4211
loop_body_4211:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4211
; >ENTER_DEC_DATA 2351
%dataptr_2351 = load i32, i32* %dataptr_addr
%element_addr_2351 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2351
%element_2351 = load i8, i8* %element_addr_2351
%sub_element_2351 = sub i8 %element_2351, 1
store i8 %sub_element_2351, i8* %element_addr_2351
; <ENTER_DEC_DATA 2351
; >ENTER_DEC_PTR 2352
%dataptr_2352 = load i32, i32* %dataptr_addr
%dec_dataptr_2352 = sub i32 %dataptr_2352, 7
store i32 %dec_dataptr_2352, i32* %dataptr_addr
; <ENTER_DEC_PTR 2352
; >ENTER_INC_DATA 2359
%dataptr_2359 = load i32, i32* %dataptr_addr
%element_addr_2359 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2359
%element_2359 = load i8, i8* %element_addr_2359
%inc_element_2359 = add i8 %element_2359, 1
store i8 %inc_element_2359, i8* %element_addr_2359
; <ENTER_INC_DATA 2359
; >ENTER_INC_PTR 2360
%dataptr_2360 = load i32, i32* %dataptr_addr
%inc_dataptr_2360 = add i32 %dataptr_2360, 7
store i32 %inc_dataptr_2360, i32* %dataptr_addr
; <ENTER_INC_PTR 2360
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4210
%dataptr_enter_4210 = load i32, i32* %dataptr_addr
%element_addr_enter_4210 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4210
%element_enter_4210 = load i8, i8* %element_addr_enter_4210
%compare_zero_enter_4210 = icmp eq i8 %element_enter_4210, 0
br i1 %compare_zero_enter_4210, label %post_loop_4210, label %loop_body_4210
loop_body_4210:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4210
; >ENTER_DEC_DATA 2368
%dataptr_2368 = load i32, i32* %dataptr_addr
%element_addr_2368 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2368
%element_2368 = load i8, i8* %element_addr_2368
%sub_element_2368 = sub i8 %element_2368, 1
store i8 %sub_element_2368, i8* %element_addr_2368
; <ENTER_DEC_DATA 2368
; >ENTER_DEC_PTR 2369
%dataptr_2369 = load i32, i32* %dataptr_addr
%dec_dataptr_2369 = sub i32 %dataptr_2369, 7
store i32 %dec_dataptr_2369, i32* %dataptr_addr
; <ENTER_DEC_PTR 2369
; >ENTER_DEC_DATA 2376
%dataptr_2376 = load i32, i32* %dataptr_addr
%element_addr_2376 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2376
%element_2376 = load i8, i8* %element_addr_2376
%sub_element_2376 = sub i8 %element_2376, 1
store i8 %sub_element_2376, i8* %element_addr_2376
; <ENTER_DEC_DATA 2376
; >ENTER_INC_PTR 2377
%dataptr_2377 = load i32, i32* %dataptr_addr
%inc_dataptr_2377 = add i32 %dataptr_2377, 6
store i32 %inc_dataptr_2377, i32* %dataptr_addr
; <ENTER_INC_PTR 2377
; >ENTER_INC_DATA 2383
%dataptr_2383 = load i32, i32* %dataptr_addr
%element_addr_2383 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2383
%element_2383 = load i8, i8* %element_addr_2383
%inc_element_2383 = add i8 %element_2383, 1
store i8 %inc_element_2383, i8* %element_addr_2383
; <ENTER_INC_DATA 2383
; >ENTER_INC_PTR 2384
%dataptr_2384 = load i32, i32* %dataptr_addr
%inc_dataptr_2384 = add i32 %dataptr_2384, 1
store i32 %inc_dataptr_2384, i32* %dataptr_addr
; <ENTER_INC_PTR 2384
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4209
%dataptr_enter_4209 = load i32, i32* %dataptr_addr
%element_addr_enter_4209 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4209
%element_enter_4209 = load i8, i8* %element_addr_enter_4209
%compare_zero_enter_4209 = icmp eq i8 %element_enter_4209, 0
br i1 %compare_zero_enter_4209, label %post_loop_4209, label %loop_body_4209
loop_body_4209:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4209
; >ENTER_DEC_DATA 2387
%dataptr_2387 = load i32, i32* %dataptr_addr
%element_addr_2387 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2387
%element_2387 = load i8, i8* %element_addr_2387
%sub_element_2387 = sub i8 %element_2387, 1
store i8 %sub_element_2387, i8* %element_addr_2387
; <ENTER_DEC_DATA 2387
; >ENTER_DEC_PTR 2388
%dataptr_2388 = load i32, i32* %dataptr_addr
%dec_dataptr_2388 = sub i32 %dataptr_2388, 7
store i32 %dec_dataptr_2388, i32* %dataptr_addr
; <ENTER_DEC_PTR 2388
; >ENTER_INC_DATA 2395
%dataptr_2395 = load i32, i32* %dataptr_addr
%element_addr_2395 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2395
%element_2395 = load i8, i8* %element_addr_2395
%inc_element_2395 = add i8 %element_2395, 1
store i8 %inc_element_2395, i8* %element_addr_2395
; <ENTER_INC_DATA 2395
; >ENTER_INC_PTR 2396
%dataptr_2396 = load i32, i32* %dataptr_addr
%inc_dataptr_2396 = add i32 %dataptr_2396, 7
store i32 %inc_dataptr_2396, i32* %dataptr_addr
; <ENTER_INC_PTR 2396
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4208
%dataptr_enter_4208 = load i32, i32* %dataptr_addr
%element_addr_enter_4208 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4208
%element_enter_4208 = load i8, i8* %element_addr_enter_4208
%compare_zero_enter_4208 = icmp eq i8 %element_enter_4208, 0
br i1 %compare_zero_enter_4208, label %post_loop_4208, label %loop_body_4208
loop_body_4208:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4208
; >ENTER_DEC_DATA 2404
%dataptr_2404 = load i32, i32* %dataptr_addr
%element_addr_2404 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2404
%element_2404 = load i8, i8* %element_addr_2404
%sub_element_2404 = sub i8 %element_2404, 1
store i8 %sub_element_2404, i8* %element_addr_2404
; <ENTER_DEC_DATA 2404
; >ENTER_DEC_PTR 2405
%dataptr_2405 = load i32, i32* %dataptr_addr
%dec_dataptr_2405 = sub i32 %dataptr_2405, 7
store i32 %dec_dataptr_2405, i32* %dataptr_addr
; <ENTER_DEC_PTR 2405
; >ENTER_DEC_DATA 2412
%dataptr_2412 = load i32, i32* %dataptr_addr
%element_addr_2412 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2412
%element_2412 = load i8, i8* %element_addr_2412
%sub_element_2412 = sub i8 %element_2412, 1
store i8 %sub_element_2412, i8* %element_addr_2412
; <ENTER_DEC_DATA 2412
; >ENTER_INC_PTR 2413
%dataptr_2413 = load i32, i32* %dataptr_addr
%inc_dataptr_2413 = add i32 %dataptr_2413, 6
store i32 %inc_dataptr_2413, i32* %dataptr_addr
; <ENTER_INC_PTR 2413
; >ENTER_INC_DATA 2419
%dataptr_2419 = load i32, i32* %dataptr_addr
%element_addr_2419 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2419
%element_2419 = load i8, i8* %element_addr_2419
%inc_element_2419 = add i8 %element_2419, 1
store i8 %inc_element_2419, i8* %element_addr_2419
; <ENTER_INC_DATA 2419
; >ENTER_INC_PTR 2420
%dataptr_2420 = load i32, i32* %dataptr_addr
%inc_dataptr_2420 = add i32 %dataptr_2420, 1
store i32 %inc_dataptr_2420, i32* %dataptr_addr
; <ENTER_INC_PTR 2420
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4207
%dataptr_enter_4207 = load i32, i32* %dataptr_addr
%element_addr_enter_4207 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4207
%element_enter_4207 = load i8, i8* %element_addr_enter_4207
%compare_zero_enter_4207 = icmp eq i8 %element_enter_4207, 0
br i1 %compare_zero_enter_4207, label %post_loop_4207, label %loop_body_4207
loop_body_4207:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4207
; >ENTER_DEC_DATA 2423
%dataptr_2423 = load i32, i32* %dataptr_addr
%element_addr_2423 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2423
%element_2423 = load i8, i8* %element_addr_2423
%sub_element_2423 = sub i8 %element_2423, 1
store i8 %sub_element_2423, i8* %element_addr_2423
; <ENTER_DEC_DATA 2423
; >ENTER_DEC_PTR 2424
%dataptr_2424 = load i32, i32* %dataptr_addr
%dec_dataptr_2424 = sub i32 %dataptr_2424, 7
store i32 %dec_dataptr_2424, i32* %dataptr_addr
; <ENTER_DEC_PTR 2424
; >ENTER_INC_DATA 2431
%dataptr_2431 = load i32, i32* %dataptr_addr
%element_addr_2431 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2431
%element_2431 = load i8, i8* %element_addr_2431
%inc_element_2431 = add i8 %element_2431, 1
store i8 %inc_element_2431, i8* %element_addr_2431
; <ENTER_INC_DATA 2431
; >ENTER_INC_PTR 2432
%dataptr_2432 = load i32, i32* %dataptr_addr
%inc_dataptr_2432 = add i32 %dataptr_2432, 7
store i32 %inc_dataptr_2432, i32* %dataptr_addr
; <ENTER_INC_PTR 2432
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4207
%dataptr_leave_4207 = load i32, i32* %dataptr_addr
%element_addr_leave_4207 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4207
%element_leave_4207 = load i8, i8* %element_addr_leave_4207
%compare_zero_leave_4207 = icmp ne i8 %element_leave_4207, 0
br i1 %compare_zero_leave_4207, label %loop_body_4207, label %post_loop_4207
post_loop_4207:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4207
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4208
%dataptr_leave_4208 = load i32, i32* %dataptr_addr
%element_addr_leave_4208 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4208
%element_leave_4208 = load i8, i8* %element_addr_leave_4208
%compare_zero_leave_4208 = icmp ne i8 %element_leave_4208, 0
br i1 %compare_zero_leave_4208, label %loop_body_4208, label %post_loop_4208
post_loop_4208:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4208
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4209
%dataptr_leave_4209 = load i32, i32* %dataptr_addr
%element_addr_leave_4209 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4209
%element_leave_4209 = load i8, i8* %element_addr_leave_4209
%compare_zero_leave_4209 = icmp ne i8 %element_leave_4209, 0
br i1 %compare_zero_leave_4209, label %loop_body_4209, label %post_loop_4209
post_loop_4209:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4209
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4210
%dataptr_leave_4210 = load i32, i32* %dataptr_addr
%element_addr_leave_4210 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4210
%element_leave_4210 = load i8, i8* %element_addr_leave_4210
%compare_zero_leave_4210 = icmp ne i8 %element_leave_4210, 0
br i1 %compare_zero_leave_4210, label %loop_body_4210, label %post_loop_4210
post_loop_4210:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4210
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4211
%dataptr_leave_4211 = load i32, i32* %dataptr_addr
%element_addr_leave_4211 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4211
%element_leave_4211 = load i8, i8* %element_addr_leave_4211
%compare_zero_leave_4211 = icmp ne i8 %element_leave_4211, 0
br i1 %compare_zero_leave_4211, label %loop_body_4211, label %post_loop_4211
post_loop_4211:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4211
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4212
%dataptr_leave_4212 = load i32, i32* %dataptr_addr
%element_addr_leave_4212 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4212
%element_leave_4212 = load i8, i8* %element_addr_leave_4212
%compare_zero_leave_4212 = icmp ne i8 %element_leave_4212, 0
br i1 %compare_zero_leave_4212, label %loop_body_4212, label %post_loop_4212
post_loop_4212:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4212
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4213
%dataptr_leave_4213 = load i32, i32* %dataptr_addr
%element_addr_leave_4213 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4213
%element_leave_4213 = load i8, i8* %element_addr_leave_4213
%compare_zero_leave_4213 = icmp ne i8 %element_leave_4213, 0
br i1 %compare_zero_leave_4213, label %loop_body_4213, label %post_loop_4213
post_loop_4213:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4213
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4214
%dataptr_leave_4214 = load i32, i32* %dataptr_addr
%element_addr_leave_4214 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4214
%element_leave_4214 = load i8, i8* %element_addr_leave_4214
%compare_zero_leave_4214 = icmp ne i8 %element_leave_4214, 0
br i1 %compare_zero_leave_4214, label %loop_body_4214, label %post_loop_4214
post_loop_4214:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4214
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4215
%dataptr_leave_4215 = load i32, i32* %dataptr_addr
%element_addr_leave_4215 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4215
%element_leave_4215 = load i8, i8* %element_addr_leave_4215
%compare_zero_leave_4215 = icmp ne i8 %element_leave_4215, 0
br i1 %compare_zero_leave_4215, label %loop_body_4215, label %post_loop_4215
post_loop_4215:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4215
; >ENTER_DEC_PTR 2448
%dataptr_2448 = load i32, i32* %dataptr_addr
%dec_dataptr_2448 = sub i32 %dataptr_2448, 7
store i32 %dec_dataptr_2448, i32* %dataptr_addr
; <ENTER_DEC_PTR 2448
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4216
%dataptr_enter_4216 = load i32, i32* %dataptr_addr
%element_addr_enter_4216 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4216
%element_enter_4216 = load i8, i8* %element_addr_enter_4216
%compare_zero_enter_4216 = icmp eq i8 %element_enter_4216, 0
br i1 %compare_zero_enter_4216, label %post_loop_4216, label %loop_body_4216
loop_body_4216:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4216
; >ENTER_DEC_DATA 2457
%dataptr_2457 = load i32, i32* %dataptr_addr
%element_addr_2457 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2457
%element_2457 = load i8, i8* %element_addr_2457
%sub_element_2457 = sub i8 %element_2457, 1
store i8 %sub_element_2457, i8* %element_addr_2457
; <ENTER_DEC_DATA 2457
; >ENTER_INC_PTR 2458
%dataptr_2458 = load i32, i32* %dataptr_addr
%inc_dataptr_2458 = add i32 %dataptr_2458, 7
store i32 %inc_dataptr_2458, i32* %dataptr_addr
; <ENTER_INC_PTR 2458
; >ENTER_INC_DATA 2465
%dataptr_2465 = load i32, i32* %dataptr_addr
%element_addr_2465 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2465
%element_2465 = load i8, i8* %element_addr_2465
%inc_element_2465 = add i8 %element_2465, 1
store i8 %inc_element_2465, i8* %element_addr_2465
; <ENTER_INC_DATA 2465
; >ENTER_DEC_PTR 2466
%dataptr_2466 = load i32, i32* %dataptr_addr
%dec_dataptr_2466 = sub i32 %dataptr_2466, 7
store i32 %dec_dataptr_2466, i32* %dataptr_addr
; <ENTER_DEC_PTR 2466
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4216
%dataptr_leave_4216 = load i32, i32* %dataptr_addr
%element_addr_leave_4216 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4216
%element_leave_4216 = load i8, i8* %element_addr_leave_4216
%compare_zero_leave_4216 = icmp ne i8 %element_leave_4216, 0
br i1 %compare_zero_leave_4216, label %loop_body_4216, label %post_loop_4216
post_loop_4216:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4216
; >ENTER_DEC_DATA 2474
%dataptr_2474 = load i32, i32* %dataptr_addr
%element_addr_2474 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2474
%element_2474 = load i8, i8* %element_addr_2474
%sub_element_2474 = sub i8 %element_2474, 1
store i8 %sub_element_2474, i8* %element_addr_2474
; <ENTER_DEC_DATA 2474
; >ENTER_DEC_PTR 2475
%dataptr_2475 = load i32, i32* %dataptr_addr
%dec_dataptr_2475 = sub i32 %dataptr_2475, 10
store i32 %dec_dataptr_2475, i32* %dataptr_addr
; <ENTER_DEC_PTR 2475
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4217
%dataptr_leave_4217 = load i32, i32* %dataptr_addr
%element_addr_leave_4217 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4217
%element_leave_4217 = load i8, i8* %element_addr_leave_4217
%compare_zero_leave_4217 = icmp ne i8 %element_leave_4217, 0
br i1 %compare_zero_leave_4217, label %loop_body_4217, label %post_loop_4217
post_loop_4217:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4217
; >ENTER_INC_PTR 2487
%dataptr_2487 = load i32, i32* %dataptr_addr
%inc_dataptr_2487 = add i32 %dataptr_2487, 7
store i32 %inc_dataptr_2487, i32* %dataptr_addr
; <ENTER_INC_PTR 2487
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4218
%dataptr_enter_4218 = load i32, i32* %dataptr_addr
%element_addr_enter_4218 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4218
%element_enter_4218 = load i8, i8* %element_addr_enter_4218
%compare_zero_enter_4218 = icmp eq i8 %element_enter_4218, 0
br i1 %compare_zero_enter_4218, label %post_loop_4218, label %loop_body_4218
loop_body_4218:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4218
; >ENTER_DEC_DATA 2496
%dataptr_2496 = load i32, i32* %dataptr_addr
%element_addr_2496 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2496
%element_2496 = load i8, i8* %element_addr_2496
%sub_element_2496 = sub i8 %element_2496, 1
store i8 %sub_element_2496, i8* %element_addr_2496
; <ENTER_DEC_DATA 2496
; >ENTER_DEC_PTR 2497
%dataptr_2497 = load i32, i32* %dataptr_addr
%dec_dataptr_2497 = sub i32 %dataptr_2497, 11
store i32 %dec_dataptr_2497, i32* %dataptr_addr
; <ENTER_DEC_PTR 2497
; >ENTER_INC_DATA 2508
%dataptr_2508 = load i32, i32* %dataptr_addr
%element_addr_2508 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2508
%element_2508 = load i8, i8* %element_addr_2508
%inc_element_2508 = add i8 %element_2508, 1
store i8 %inc_element_2508, i8* %element_addr_2508
; <ENTER_INC_DATA 2508
; >ENTER_INC_PTR 2509
%dataptr_2509 = load i32, i32* %dataptr_addr
%inc_dataptr_2509 = add i32 %dataptr_2509, 11
store i32 %inc_dataptr_2509, i32* %dataptr_addr
; <ENTER_INC_PTR 2509
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4218
%dataptr_leave_4218 = load i32, i32* %dataptr_addr
%element_addr_leave_4218 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4218
%element_leave_4218 = load i8, i8* %element_addr_leave_4218
%compare_zero_leave_4218 = icmp ne i8 %element_leave_4218, 0
br i1 %compare_zero_leave_4218, label %loop_body_4218, label %post_loop_4218
post_loop_4218:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4218
; >ENTER_INC_PTR 2522
%dataptr_2522 = load i32, i32* %dataptr_addr
%inc_dataptr_2522 = add i32 %dataptr_2522, 3
store i32 %inc_dataptr_2522, i32* %dataptr_addr
; <ENTER_INC_PTR 2522
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4220
%dataptr_enter_4220 = load i32, i32* %dataptr_addr
%element_addr_enter_4220 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4220
%element_enter_4220 = load i8, i8* %element_addr_enter_4220
%compare_zero_enter_4220 = icmp eq i8 %element_enter_4220, 0
br i1 %compare_zero_enter_4220, label %post_loop_4220, label %loop_body_4220
loop_body_4220:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4220
; >ENTER_INC_PTR 2526
%dataptr_2526 = load i32, i32* %dataptr_addr
%inc_dataptr_2526 = add i32 %dataptr_2526, 7
store i32 %inc_dataptr_2526, i32* %dataptr_addr
; <ENTER_INC_PTR 2526
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4219
%dataptr_enter_4219 = load i32, i32* %dataptr_addr
%element_addr_enter_4219 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4219
%element_enter_4219 = load i8, i8* %element_addr_enter_4219
%compare_zero_enter_4219 = icmp eq i8 %element_enter_4219, 0
br i1 %compare_zero_enter_4219, label %post_loop_4219, label %loop_body_4219
loop_body_4219:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4219
; >ENTER_DEC_DATA 2534
%dataptr_2534 = load i32, i32* %dataptr_addr
%element_addr_2534 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2534
%element_2534 = load i8, i8* %element_addr_2534
%sub_element_2534 = sub i8 %element_2534, 1
store i8 %sub_element_2534, i8* %element_addr_2534
; <ENTER_DEC_DATA 2534
; >ENTER_DEC_PTR 2535
%dataptr_2535 = load i32, i32* %dataptr_addr
%dec_dataptr_2535 = sub i32 %dataptr_2535, 11
store i32 %dec_dataptr_2535, i32* %dataptr_addr
; <ENTER_DEC_PTR 2535
; >ENTER_INC_DATA 2546
%dataptr_2546 = load i32, i32* %dataptr_addr
%element_addr_2546 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2546
%element_2546 = load i8, i8* %element_addr_2546
%inc_element_2546 = add i8 %element_2546, 5
store i8 %inc_element_2546, i8* %element_addr_2546
; <ENTER_INC_DATA 2546
; >ENTER_INC_PTR 2551
%dataptr_2551 = load i32, i32* %dataptr_addr
%inc_dataptr_2551 = add i32 %dataptr_2551, 11
store i32 %inc_dataptr_2551, i32* %dataptr_addr
; <ENTER_INC_PTR 2551
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4219
%dataptr_leave_4219 = load i32, i32* %dataptr_addr
%element_addr_leave_4219 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4219
%element_leave_4219 = load i8, i8* %element_addr_leave_4219
%compare_zero_leave_4219 = icmp ne i8 %element_leave_4219, 0
br i1 %compare_zero_leave_4219, label %loop_body_4219, label %post_loop_4219
post_loop_4219:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4219
; >ENTER_INC_PTR 2563
%dataptr_2563 = load i32, i32* %dataptr_addr
%inc_dataptr_2563 = add i32 %dataptr_2563, 3
store i32 %inc_dataptr_2563, i32* %dataptr_addr
; <ENTER_INC_PTR 2563
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4220
%dataptr_leave_4220 = load i32, i32* %dataptr_addr
%element_addr_leave_4220 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4220
%element_leave_4220 = load i8, i8* %element_addr_leave_4220
%compare_zero_leave_4220 = icmp ne i8 %element_leave_4220, 0
br i1 %compare_zero_leave_4220, label %loop_body_4220, label %post_loop_4220
post_loop_4220:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4220
; >ENTER_DEC_PTR 2567
%dataptr_2567 = load i32, i32* %dataptr_addr
%dec_dataptr_2567 = sub i32 %dataptr_2567, 10
store i32 %dec_dataptr_2567, i32* %dataptr_addr
; <ENTER_DEC_PTR 2567
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4231
%dataptr_enter_4231 = load i32, i32* %dataptr_addr
%element_addr_enter_4231 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4231
%element_enter_4231 = load i8, i8* %element_addr_enter_4231
%compare_zero_enter_4231 = icmp eq i8 %element_enter_4231, 0
br i1 %compare_zero_enter_4231, label %post_loop_4231, label %loop_body_4231
loop_body_4231:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4231
; >ENTER_INC_DATA 2579
%dataptr_2579 = load i32, i32* %dataptr_addr
%element_addr_2579 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2579
%element_2579 = load i8, i8* %element_addr_2579
%inc_element_2579 = add i8 %element_2579, 1
store i8 %inc_element_2579, i8* %element_addr_2579
; <ENTER_INC_DATA 2579
; >ENTER_INC_PTR 2580
%dataptr_2580 = load i32, i32* %dataptr_addr
%inc_dataptr_2580 = add i32 %dataptr_2580, 8
store i32 %inc_dataptr_2580, i32* %dataptr_addr
; <ENTER_INC_PTR 2580
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4229
%dataptr_enter_4229 = load i32, i32* %dataptr_addr
%element_addr_enter_4229 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4229
%element_enter_4229 = load i8, i8* %element_addr_enter_4229
%compare_zero_enter_4229 = icmp eq i8 %element_enter_4229, 0
br i1 %compare_zero_enter_4229, label %post_loop_4229, label %loop_body_4229
loop_body_4229:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4229
; >ENTER_DEC_DATA 2589
%dataptr_2589 = load i32, i32* %dataptr_addr
%element_addr_2589 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2589
%element_2589 = load i8, i8* %element_addr_2589
%sub_element_2589 = sub i8 %element_2589, 1
store i8 %sub_element_2589, i8* %element_addr_2589
; <ENTER_DEC_DATA 2589
; >ENTER_DEC_PTR 2590
%dataptr_2590 = load i32, i32* %dataptr_addr
%dec_dataptr_2590 = sub i32 %dataptr_2590, 8
store i32 %dec_dataptr_2590, i32* %dataptr_addr
; <ENTER_DEC_PTR 2590
; >ENTER_INC_DATA 2598
%dataptr_2598 = load i32, i32* %dataptr_addr
%element_addr_2598 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2598
%element_2598 = load i8, i8* %element_addr_2598
%inc_element_2598 = add i8 %element_2598, 1
store i8 %inc_element_2598, i8* %element_addr_2598
; <ENTER_INC_DATA 2598
; >ENTER_INC_PTR 2599
%dataptr_2599 = load i32, i32* %dataptr_addr
%inc_dataptr_2599 = add i32 %dataptr_2599, 8
store i32 %inc_dataptr_2599, i32* %dataptr_addr
; <ENTER_INC_PTR 2599
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4228
%dataptr_enter_4228 = load i32, i32* %dataptr_addr
%element_addr_enter_4228 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4228
%element_enter_4228 = load i8, i8* %element_addr_enter_4228
%compare_zero_enter_4228 = icmp eq i8 %element_enter_4228, 0
br i1 %compare_zero_enter_4228, label %post_loop_4228, label %loop_body_4228
loop_body_4228:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4228
; >ENTER_DEC_DATA 2608
%dataptr_2608 = load i32, i32* %dataptr_addr
%element_addr_2608 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2608
%element_2608 = load i8, i8* %element_addr_2608
%sub_element_2608 = sub i8 %element_2608, 1
store i8 %sub_element_2608, i8* %element_addr_2608
; <ENTER_DEC_DATA 2608
; >ENTER_DEC_PTR 2609
%dataptr_2609 = load i32, i32* %dataptr_addr
%dec_dataptr_2609 = sub i32 %dataptr_2609, 8
store i32 %dec_dataptr_2609, i32* %dataptr_addr
; <ENTER_DEC_PTR 2609
; >ENTER_DEC_DATA 2617
%dataptr_2617 = load i32, i32* %dataptr_addr
%element_addr_2617 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2617
%element_2617 = load i8, i8* %element_addr_2617
%sub_element_2617 = sub i8 %element_2617, 1
store i8 %sub_element_2617, i8* %element_addr_2617
; <ENTER_DEC_DATA 2617
; >ENTER_INC_PTR 2618
%dataptr_2618 = load i32, i32* %dataptr_addr
%inc_dataptr_2618 = add i32 %dataptr_2618, 5
store i32 %inc_dataptr_2618, i32* %dataptr_addr
; <ENTER_INC_PTR 2618
; >ENTER_INC_DATA 2623
%dataptr_2623 = load i32, i32* %dataptr_addr
%element_addr_2623 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2623
%element_2623 = load i8, i8* %element_addr_2623
%inc_element_2623 = add i8 %element_2623, 1
store i8 %inc_element_2623, i8* %element_addr_2623
; <ENTER_INC_DATA 2623
; >ENTER_INC_PTR 2624
%dataptr_2624 = load i32, i32* %dataptr_addr
%inc_dataptr_2624 = add i32 %dataptr_2624, 3
store i32 %inc_dataptr_2624, i32* %dataptr_addr
; <ENTER_INC_PTR 2624
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4227
%dataptr_enter_4227 = load i32, i32* %dataptr_addr
%element_addr_enter_4227 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4227
%element_enter_4227 = load i8, i8* %element_addr_enter_4227
%compare_zero_enter_4227 = icmp eq i8 %element_enter_4227, 0
br i1 %compare_zero_enter_4227, label %post_loop_4227, label %loop_body_4227
loop_body_4227:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4227
; >ENTER_DEC_DATA 2629
%dataptr_2629 = load i32, i32* %dataptr_addr
%element_addr_2629 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2629
%element_2629 = load i8, i8* %element_addr_2629
%sub_element_2629 = sub i8 %element_2629, 1
store i8 %sub_element_2629, i8* %element_addr_2629
; <ENTER_DEC_DATA 2629
; >ENTER_DEC_PTR 2630
%dataptr_2630 = load i32, i32* %dataptr_addr
%dec_dataptr_2630 = sub i32 %dataptr_2630, 8
store i32 %dec_dataptr_2630, i32* %dataptr_addr
; <ENTER_DEC_PTR 2630
; >ENTER_INC_DATA 2638
%dataptr_2638 = load i32, i32* %dataptr_addr
%element_addr_2638 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2638
%element_2638 = load i8, i8* %element_addr_2638
%inc_element_2638 = add i8 %element_2638, 1
store i8 %inc_element_2638, i8* %element_addr_2638
; <ENTER_INC_DATA 2638
; >ENTER_INC_PTR 2639
%dataptr_2639 = load i32, i32* %dataptr_addr
%inc_dataptr_2639 = add i32 %dataptr_2639, 8
store i32 %inc_dataptr_2639, i32* %dataptr_addr
; <ENTER_INC_PTR 2639
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4226
%dataptr_enter_4226 = load i32, i32* %dataptr_addr
%element_addr_enter_4226 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4226
%element_enter_4226 = load i8, i8* %element_addr_enter_4226
%compare_zero_enter_4226 = icmp eq i8 %element_enter_4226, 0
br i1 %compare_zero_enter_4226, label %post_loop_4226, label %loop_body_4226
loop_body_4226:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4226
; >ENTER_DEC_DATA 2648
%dataptr_2648 = load i32, i32* %dataptr_addr
%element_addr_2648 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2648
%element_2648 = load i8, i8* %element_addr_2648
%sub_element_2648 = sub i8 %element_2648, 1
store i8 %sub_element_2648, i8* %element_addr_2648
; <ENTER_DEC_DATA 2648
; >ENTER_DEC_PTR 2649
%dataptr_2649 = load i32, i32* %dataptr_addr
%dec_dataptr_2649 = sub i32 %dataptr_2649, 8
store i32 %dec_dataptr_2649, i32* %dataptr_addr
; <ENTER_DEC_PTR 2649
; >ENTER_DEC_DATA 2657
%dataptr_2657 = load i32, i32* %dataptr_addr
%element_addr_2657 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2657
%element_2657 = load i8, i8* %element_addr_2657
%sub_element_2657 = sub i8 %element_2657, 1
store i8 %sub_element_2657, i8* %element_addr_2657
; <ENTER_DEC_DATA 2657
; >ENTER_INC_PTR 2658
%dataptr_2658 = load i32, i32* %dataptr_addr
%inc_dataptr_2658 = add i32 %dataptr_2658, 5
store i32 %inc_dataptr_2658, i32* %dataptr_addr
; <ENTER_INC_PTR 2658
; >ENTER_INC_DATA 2663
%dataptr_2663 = load i32, i32* %dataptr_addr
%element_addr_2663 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2663
%element_2663 = load i8, i8* %element_addr_2663
%inc_element_2663 = add i8 %element_2663, 1
store i8 %inc_element_2663, i8* %element_addr_2663
; <ENTER_INC_DATA 2663
; >ENTER_INC_PTR 2664
%dataptr_2664 = load i32, i32* %dataptr_addr
%inc_dataptr_2664 = add i32 %dataptr_2664, 3
store i32 %inc_dataptr_2664, i32* %dataptr_addr
; <ENTER_INC_PTR 2664
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4225
%dataptr_enter_4225 = load i32, i32* %dataptr_addr
%element_addr_enter_4225 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4225
%element_enter_4225 = load i8, i8* %element_addr_enter_4225
%compare_zero_enter_4225 = icmp eq i8 %element_enter_4225, 0
br i1 %compare_zero_enter_4225, label %post_loop_4225, label %loop_body_4225
loop_body_4225:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4225
; >ENTER_DEC_DATA 2669
%dataptr_2669 = load i32, i32* %dataptr_addr
%element_addr_2669 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2669
%element_2669 = load i8, i8* %element_addr_2669
%sub_element_2669 = sub i8 %element_2669, 1
store i8 %sub_element_2669, i8* %element_addr_2669
; <ENTER_DEC_DATA 2669
; >ENTER_DEC_PTR 2670
%dataptr_2670 = load i32, i32* %dataptr_addr
%dec_dataptr_2670 = sub i32 %dataptr_2670, 8
store i32 %dec_dataptr_2670, i32* %dataptr_addr
; <ENTER_DEC_PTR 2670
; >ENTER_INC_DATA 2678
%dataptr_2678 = load i32, i32* %dataptr_addr
%element_addr_2678 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2678
%element_2678 = load i8, i8* %element_addr_2678
%inc_element_2678 = add i8 %element_2678, 1
store i8 %inc_element_2678, i8* %element_addr_2678
; <ENTER_INC_DATA 2678
; >ENTER_INC_PTR 2679
%dataptr_2679 = load i32, i32* %dataptr_addr
%inc_dataptr_2679 = add i32 %dataptr_2679, 8
store i32 %inc_dataptr_2679, i32* %dataptr_addr
; <ENTER_INC_PTR 2679
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4224
%dataptr_enter_4224 = load i32, i32* %dataptr_addr
%element_addr_enter_4224 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4224
%element_enter_4224 = load i8, i8* %element_addr_enter_4224
%compare_zero_enter_4224 = icmp eq i8 %element_enter_4224, 0
br i1 %compare_zero_enter_4224, label %post_loop_4224, label %loop_body_4224
loop_body_4224:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4224
; >ENTER_DEC_DATA 2688
%dataptr_2688 = load i32, i32* %dataptr_addr
%element_addr_2688 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2688
%element_2688 = load i8, i8* %element_addr_2688
%sub_element_2688 = sub i8 %element_2688, 1
store i8 %sub_element_2688, i8* %element_addr_2688
; <ENTER_DEC_DATA 2688
; >ENTER_DEC_PTR 2689
%dataptr_2689 = load i32, i32* %dataptr_addr
%dec_dataptr_2689 = sub i32 %dataptr_2689, 8
store i32 %dec_dataptr_2689, i32* %dataptr_addr
; <ENTER_DEC_PTR 2689
; >ENTER_DEC_DATA 2697
%dataptr_2697 = load i32, i32* %dataptr_addr
%element_addr_2697 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2697
%element_2697 = load i8, i8* %element_addr_2697
%sub_element_2697 = sub i8 %element_2697, 1
store i8 %sub_element_2697, i8* %element_addr_2697
; <ENTER_DEC_DATA 2697
; >ENTER_INC_PTR 2698
%dataptr_2698 = load i32, i32* %dataptr_addr
%inc_dataptr_2698 = add i32 %dataptr_2698, 5
store i32 %inc_dataptr_2698, i32* %dataptr_addr
; <ENTER_INC_PTR 2698
; >ENTER_INC_DATA 2703
%dataptr_2703 = load i32, i32* %dataptr_addr
%element_addr_2703 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2703
%element_2703 = load i8, i8* %element_addr_2703
%inc_element_2703 = add i8 %element_2703, 1
store i8 %inc_element_2703, i8* %element_addr_2703
; <ENTER_INC_DATA 2703
; >ENTER_INC_PTR 2704
%dataptr_2704 = load i32, i32* %dataptr_addr
%inc_dataptr_2704 = add i32 %dataptr_2704, 3
store i32 %inc_dataptr_2704, i32* %dataptr_addr
; <ENTER_INC_PTR 2704
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4223
%dataptr_enter_4223 = load i32, i32* %dataptr_addr
%element_addr_enter_4223 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4223
%element_enter_4223 = load i8, i8* %element_addr_enter_4223
%compare_zero_enter_4223 = icmp eq i8 %element_enter_4223, 0
br i1 %compare_zero_enter_4223, label %post_loop_4223, label %loop_body_4223
loop_body_4223:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4223
; >ENTER_DEC_DATA 2709
%dataptr_2709 = load i32, i32* %dataptr_addr
%element_addr_2709 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2709
%element_2709 = load i8, i8* %element_addr_2709
%sub_element_2709 = sub i8 %element_2709, 1
store i8 %sub_element_2709, i8* %element_addr_2709
; <ENTER_DEC_DATA 2709
; >ENTER_DEC_PTR 2710
%dataptr_2710 = load i32, i32* %dataptr_addr
%dec_dataptr_2710 = sub i32 %dataptr_2710, 8
store i32 %dec_dataptr_2710, i32* %dataptr_addr
; <ENTER_DEC_PTR 2710
; >ENTER_INC_DATA 2718
%dataptr_2718 = load i32, i32* %dataptr_addr
%element_addr_2718 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2718
%element_2718 = load i8, i8* %element_addr_2718
%inc_element_2718 = add i8 %element_2718, 1
store i8 %inc_element_2718, i8* %element_addr_2718
; <ENTER_INC_DATA 2718
; >ENTER_INC_PTR 2719
%dataptr_2719 = load i32, i32* %dataptr_addr
%inc_dataptr_2719 = add i32 %dataptr_2719, 8
store i32 %inc_dataptr_2719, i32* %dataptr_addr
; <ENTER_INC_PTR 2719
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4222
%dataptr_enter_4222 = load i32, i32* %dataptr_addr
%element_addr_enter_4222 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4222
%element_enter_4222 = load i8, i8* %element_addr_enter_4222
%compare_zero_enter_4222 = icmp eq i8 %element_enter_4222, 0
br i1 %compare_zero_enter_4222, label %post_loop_4222, label %loop_body_4222
loop_body_4222:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4222
; >ENTER_DEC_DATA 2728
%dataptr_2728 = load i32, i32* %dataptr_addr
%element_addr_2728 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2728
%element_2728 = load i8, i8* %element_addr_2728
%sub_element_2728 = sub i8 %element_2728, 1
store i8 %sub_element_2728, i8* %element_addr_2728
; <ENTER_DEC_DATA 2728
; >ENTER_DEC_PTR 2729
%dataptr_2729 = load i32, i32* %dataptr_addr
%dec_dataptr_2729 = sub i32 %dataptr_2729, 8
store i32 %dec_dataptr_2729, i32* %dataptr_addr
; <ENTER_DEC_PTR 2729
; >ENTER_DEC_DATA 2737
%dataptr_2737 = load i32, i32* %dataptr_addr
%element_addr_2737 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2737
%element_2737 = load i8, i8* %element_addr_2737
%sub_element_2737 = sub i8 %element_2737, 1
store i8 %sub_element_2737, i8* %element_addr_2737
; <ENTER_DEC_DATA 2737
; >ENTER_INC_PTR 2738
%dataptr_2738 = load i32, i32* %dataptr_addr
%inc_dataptr_2738 = add i32 %dataptr_2738, 5
store i32 %inc_dataptr_2738, i32* %dataptr_addr
; <ENTER_INC_PTR 2738
; >ENTER_INC_DATA 2743
%dataptr_2743 = load i32, i32* %dataptr_addr
%element_addr_2743 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2743
%element_2743 = load i8, i8* %element_addr_2743
%inc_element_2743 = add i8 %element_2743, 1
store i8 %inc_element_2743, i8* %element_addr_2743
; <ENTER_INC_DATA 2743
; >ENTER_INC_PTR 2744
%dataptr_2744 = load i32, i32* %dataptr_addr
%inc_dataptr_2744 = add i32 %dataptr_2744, 3
store i32 %inc_dataptr_2744, i32* %dataptr_addr
; <ENTER_INC_PTR 2744
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4221
%dataptr_enter_4221 = load i32, i32* %dataptr_addr
%element_addr_enter_4221 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4221
%element_enter_4221 = load i8, i8* %element_addr_enter_4221
%compare_zero_enter_4221 = icmp eq i8 %element_enter_4221, 0
br i1 %compare_zero_enter_4221, label %post_loop_4221, label %loop_body_4221
loop_body_4221:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4221
; >ENTER_DEC_DATA 2749
%dataptr_2749 = load i32, i32* %dataptr_addr
%element_addr_2749 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2749
%element_2749 = load i8, i8* %element_addr_2749
%sub_element_2749 = sub i8 %element_2749, 1
store i8 %sub_element_2749, i8* %element_addr_2749
; <ENTER_DEC_DATA 2749
; >ENTER_DEC_PTR 2750
%dataptr_2750 = load i32, i32* %dataptr_addr
%dec_dataptr_2750 = sub i32 %dataptr_2750, 8
store i32 %dec_dataptr_2750, i32* %dataptr_addr
; <ENTER_DEC_PTR 2750
; >ENTER_INC_DATA 2758
%dataptr_2758 = load i32, i32* %dataptr_addr
%element_addr_2758 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2758
%element_2758 = load i8, i8* %element_addr_2758
%inc_element_2758 = add i8 %element_2758, 1
store i8 %inc_element_2758, i8* %element_addr_2758
; <ENTER_INC_DATA 2758
; >ENTER_INC_PTR 2759
%dataptr_2759 = load i32, i32* %dataptr_addr
%inc_dataptr_2759 = add i32 %dataptr_2759, 8
store i32 %inc_dataptr_2759, i32* %dataptr_addr
; <ENTER_INC_PTR 2759
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4221
%dataptr_leave_4221 = load i32, i32* %dataptr_addr
%element_addr_leave_4221 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4221
%element_leave_4221 = load i8, i8* %element_addr_leave_4221
%compare_zero_leave_4221 = icmp ne i8 %element_leave_4221, 0
br i1 %compare_zero_leave_4221, label %loop_body_4221, label %post_loop_4221
post_loop_4221:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4221
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4222
%dataptr_leave_4222 = load i32, i32* %dataptr_addr
%element_addr_leave_4222 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4222
%element_leave_4222 = load i8, i8* %element_addr_leave_4222
%compare_zero_leave_4222 = icmp ne i8 %element_leave_4222, 0
br i1 %compare_zero_leave_4222, label %loop_body_4222, label %post_loop_4222
post_loop_4222:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4222
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4223
%dataptr_leave_4223 = load i32, i32* %dataptr_addr
%element_addr_leave_4223 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4223
%element_leave_4223 = load i8, i8* %element_addr_leave_4223
%compare_zero_leave_4223 = icmp ne i8 %element_leave_4223, 0
br i1 %compare_zero_leave_4223, label %loop_body_4223, label %post_loop_4223
post_loop_4223:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4223
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4224
%dataptr_leave_4224 = load i32, i32* %dataptr_addr
%element_addr_leave_4224 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4224
%element_leave_4224 = load i8, i8* %element_addr_leave_4224
%compare_zero_leave_4224 = icmp ne i8 %element_leave_4224, 0
br i1 %compare_zero_leave_4224, label %loop_body_4224, label %post_loop_4224
post_loop_4224:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4224
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4225
%dataptr_leave_4225 = load i32, i32* %dataptr_addr
%element_addr_leave_4225 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4225
%element_leave_4225 = load i8, i8* %element_addr_leave_4225
%compare_zero_leave_4225 = icmp ne i8 %element_leave_4225, 0
br i1 %compare_zero_leave_4225, label %loop_body_4225, label %post_loop_4225
post_loop_4225:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4225
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4226
%dataptr_leave_4226 = load i32, i32* %dataptr_addr
%element_addr_leave_4226 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4226
%element_leave_4226 = load i8, i8* %element_addr_leave_4226
%compare_zero_leave_4226 = icmp ne i8 %element_leave_4226, 0
br i1 %compare_zero_leave_4226, label %loop_body_4226, label %post_loop_4226
post_loop_4226:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4226
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4227
%dataptr_leave_4227 = load i32, i32* %dataptr_addr
%element_addr_leave_4227 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4227
%element_leave_4227 = load i8, i8* %element_addr_leave_4227
%compare_zero_leave_4227 = icmp ne i8 %element_leave_4227, 0
br i1 %compare_zero_leave_4227, label %loop_body_4227, label %post_loop_4227
post_loop_4227:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4227
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4228
%dataptr_leave_4228 = load i32, i32* %dataptr_addr
%element_addr_leave_4228 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4228
%element_leave_4228 = load i8, i8* %element_addr_leave_4228
%compare_zero_leave_4228 = icmp ne i8 %element_leave_4228, 0
br i1 %compare_zero_leave_4228, label %loop_body_4228, label %post_loop_4228
post_loop_4228:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4228
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4229
%dataptr_leave_4229 = load i32, i32* %dataptr_addr
%element_addr_leave_4229 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4229
%element_leave_4229 = load i8, i8* %element_addr_leave_4229
%compare_zero_leave_4229 = icmp ne i8 %element_leave_4229, 0
br i1 %compare_zero_leave_4229, label %loop_body_4229, label %post_loop_4229
post_loop_4229:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4229
; >ENTER_DEC_PTR 2776
%dataptr_2776 = load i32, i32* %dataptr_addr
%dec_dataptr_2776 = sub i32 %dataptr_2776, 8
store i32 %dec_dataptr_2776, i32* %dataptr_addr
; <ENTER_DEC_PTR 2776
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4230
%dataptr_enter_4230 = load i32, i32* %dataptr_addr
%element_addr_enter_4230 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4230
%element_enter_4230 = load i8, i8* %element_addr_enter_4230
%compare_zero_enter_4230 = icmp eq i8 %element_enter_4230, 0
br i1 %compare_zero_enter_4230, label %post_loop_4230, label %loop_body_4230
loop_body_4230:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4230
; >ENTER_DEC_DATA 2786
%dataptr_2786 = load i32, i32* %dataptr_addr
%element_addr_2786 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2786
%element_2786 = load i8, i8* %element_addr_2786
%sub_element_2786 = sub i8 %element_2786, 1
store i8 %sub_element_2786, i8* %element_addr_2786
; <ENTER_DEC_DATA 2786
; >ENTER_INC_PTR 2787
%dataptr_2787 = load i32, i32* %dataptr_addr
%inc_dataptr_2787 = add i32 %dataptr_2787, 8
store i32 %inc_dataptr_2787, i32* %dataptr_addr
; <ENTER_INC_PTR 2787
; >ENTER_INC_DATA 2795
%dataptr_2795 = load i32, i32* %dataptr_addr
%element_addr_2795 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2795
%element_2795 = load i8, i8* %element_addr_2795
%inc_element_2795 = add i8 %element_2795, 1
store i8 %inc_element_2795, i8* %element_addr_2795
; <ENTER_INC_DATA 2795
; >ENTER_DEC_PTR 2796
%dataptr_2796 = load i32, i32* %dataptr_addr
%dec_dataptr_2796 = sub i32 %dataptr_2796, 8
store i32 %dec_dataptr_2796, i32* %dataptr_addr
; <ENTER_DEC_PTR 2796
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4230
%dataptr_leave_4230 = load i32, i32* %dataptr_addr
%element_addr_leave_4230 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4230
%element_leave_4230 = load i8, i8* %element_addr_leave_4230
%compare_zero_leave_4230 = icmp ne i8 %element_leave_4230, 0
br i1 %compare_zero_leave_4230, label %loop_body_4230, label %post_loop_4230
post_loop_4230:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4230
; >ENTER_DEC_DATA 2805
%dataptr_2805 = load i32, i32* %dataptr_addr
%element_addr_2805 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2805
%element_2805 = load i8, i8* %element_addr_2805
%sub_element_2805 = sub i8 %element_2805, 1
store i8 %sub_element_2805, i8* %element_addr_2805
; <ENTER_DEC_DATA 2805
; >ENTER_DEC_PTR 2806
%dataptr_2806 = load i32, i32* %dataptr_addr
%dec_dataptr_2806 = sub i32 %dataptr_2806, 10
store i32 %dec_dataptr_2806, i32* %dataptr_addr
; <ENTER_DEC_PTR 2806
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4231
%dataptr_leave_4231 = load i32, i32* %dataptr_addr
%element_addr_leave_4231 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4231
%element_leave_4231 = load i8, i8* %element_addr_leave_4231
%compare_zero_leave_4231 = icmp ne i8 %element_leave_4231, 0
br i1 %compare_zero_leave_4231, label %loop_body_4231, label %post_loop_4231
post_loop_4231:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4231
; >ENTER_INC_PTR 2818
%dataptr_2818 = load i32, i32* %dataptr_addr
%inc_dataptr_2818 = add i32 %dataptr_2818, 8
store i32 %inc_dataptr_2818, i32* %dataptr_addr
; <ENTER_INC_PTR 2818
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4232
%dataptr_enter_4232 = load i32, i32* %dataptr_addr
%element_addr_enter_4232 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4232
%element_enter_4232 = load i8, i8* %element_addr_enter_4232
%compare_zero_enter_4232 = icmp eq i8 %element_enter_4232, 0
br i1 %compare_zero_enter_4232, label %post_loop_4232, label %loop_body_4232
loop_body_4232:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4232
; >ENTER_DEC_DATA 2827
%dataptr_2827 = load i32, i32* %dataptr_addr
%element_addr_2827 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2827
%element_2827 = load i8, i8* %element_addr_2827
%sub_element_2827 = sub i8 %element_2827, 1
store i8 %sub_element_2827, i8* %element_addr_2827
; <ENTER_DEC_DATA 2827
; >ENTER_DEC_PTR 2828
%dataptr_2828 = load i32, i32* %dataptr_addr
%dec_dataptr_2828 = sub i32 %dataptr_2828, 13
store i32 %dec_dataptr_2828, i32* %dataptr_addr
; <ENTER_DEC_PTR 2828
; >ENTER_INC_DATA 2841
%dataptr_2841 = load i32, i32* %dataptr_addr
%element_addr_2841 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2841
%element_2841 = load i8, i8* %element_addr_2841
%inc_element_2841 = add i8 %element_2841, 1
store i8 %inc_element_2841, i8* %element_addr_2841
; <ENTER_INC_DATA 2841
; >ENTER_INC_PTR 2842
%dataptr_2842 = load i32, i32* %dataptr_addr
%inc_dataptr_2842 = add i32 %dataptr_2842, 13
store i32 %inc_dataptr_2842, i32* %dataptr_addr
; <ENTER_INC_PTR 2842
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4232
%dataptr_leave_4232 = load i32, i32* %dataptr_addr
%element_addr_leave_4232 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4232
%element_leave_4232 = load i8, i8* %element_addr_leave_4232
%compare_zero_leave_4232 = icmp ne i8 %element_leave_4232, 0
br i1 %compare_zero_leave_4232, label %loop_body_4232, label %post_loop_4232
post_loop_4232:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4232
; >ENTER_INC_PTR 2856
%dataptr_2856 = load i32, i32* %dataptr_addr
%inc_dataptr_2856 = add i32 %dataptr_2856, 2
store i32 %inc_dataptr_2856, i32* %dataptr_addr
; <ENTER_INC_PTR 2856
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4234
%dataptr_enter_4234 = load i32, i32* %dataptr_addr
%element_addr_enter_4234 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4234
%element_enter_4234 = load i8, i8* %element_addr_enter_4234
%compare_zero_enter_4234 = icmp eq i8 %element_enter_4234, 0
br i1 %compare_zero_enter_4234, label %post_loop_4234, label %loop_body_4234
loop_body_4234:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4234
; >ENTER_INC_PTR 2860
%dataptr_2860 = load i32, i32* %dataptr_addr
%inc_dataptr_2860 = add i32 %dataptr_2860, 8
store i32 %inc_dataptr_2860, i32* %dataptr_addr
; <ENTER_INC_PTR 2860
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4233
%dataptr_enter_4233 = load i32, i32* %dataptr_addr
%element_addr_enter_4233 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4233
%element_enter_4233 = load i8, i8* %element_addr_enter_4233
%compare_zero_enter_4233 = icmp eq i8 %element_enter_4233, 0
br i1 %compare_zero_enter_4233, label %post_loop_4233, label %loop_body_4233
loop_body_4233:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4233
; >ENTER_DEC_DATA 2869
%dataptr_2869 = load i32, i32* %dataptr_addr
%element_addr_2869 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2869
%element_2869 = load i8, i8* %element_addr_2869
%sub_element_2869 = sub i8 %element_2869, 1
store i8 %sub_element_2869, i8* %element_addr_2869
; <ENTER_DEC_DATA 2869
; >ENTER_DEC_PTR 2870
%dataptr_2870 = load i32, i32* %dataptr_addr
%dec_dataptr_2870 = sub i32 %dataptr_2870, 13
store i32 %dec_dataptr_2870, i32* %dataptr_addr
; <ENTER_DEC_PTR 2870
; >ENTER_INC_DATA 2883
%dataptr_2883 = load i32, i32* %dataptr_addr
%element_addr_2883 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2883
%element_2883 = load i8, i8* %element_addr_2883
%inc_element_2883 = add i8 %element_2883, 5
store i8 %inc_element_2883, i8* %element_addr_2883
; <ENTER_INC_DATA 2883
; >ENTER_INC_PTR 2888
%dataptr_2888 = load i32, i32* %dataptr_addr
%inc_dataptr_2888 = add i32 %dataptr_2888, 13
store i32 %inc_dataptr_2888, i32* %dataptr_addr
; <ENTER_INC_PTR 2888
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4233
%dataptr_leave_4233 = load i32, i32* %dataptr_addr
%element_addr_leave_4233 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4233
%element_leave_4233 = load i8, i8* %element_addr_leave_4233
%compare_zero_leave_4233 = icmp ne i8 %element_leave_4233, 0
br i1 %compare_zero_leave_4233, label %loop_body_4233, label %post_loop_4233
post_loop_4233:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4233
; >ENTER_INC_PTR 2902
%dataptr_2902 = load i32, i32* %dataptr_addr
%inc_dataptr_2902 = add i32 %dataptr_2902, 2
store i32 %inc_dataptr_2902, i32* %dataptr_addr
; <ENTER_INC_PTR 2902
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4234
%dataptr_leave_4234 = load i32, i32* %dataptr_addr
%element_addr_leave_4234 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4234
%element_leave_4234 = load i8, i8* %element_addr_leave_4234
%compare_zero_leave_4234 = icmp ne i8 %element_leave_4234, 0
br i1 %compare_zero_leave_4234, label %loop_body_4234, label %post_loop_4234
post_loop_4234:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4234
; >ENTER_DEC_PTR 2905
%dataptr_2905 = load i32, i32* %dataptr_addr
%dec_dataptr_2905 = sub i32 %dataptr_2905, 10
store i32 %dec_dataptr_2905, i32* %dataptr_addr
; <ENTER_DEC_PTR 2905
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4235
%dataptr_enter_4235 = load i32, i32* %dataptr_addr
%element_addr_enter_4235 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4235
%element_enter_4235 = load i8, i8* %element_addr_enter_4235
%compare_zero_enter_4235 = icmp eq i8 %element_enter_4235, 0
br i1 %compare_zero_enter_4235, label %post_loop_4235, label %loop_body_4235
loop_body_4235:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4235
; >ENTER_DEC_PTR 2917
%dataptr_2917 = load i32, i32* %dataptr_addr
%dec_dataptr_2917 = sub i32 %dataptr_2917, 10
store i32 %dec_dataptr_2917, i32* %dataptr_addr
; <ENTER_DEC_PTR 2917
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4235
%dataptr_leave_4235 = load i32, i32* %dataptr_addr
%element_addr_leave_4235 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4235
%element_leave_4235 = load i8, i8* %element_addr_leave_4235
%compare_zero_leave_4235 = icmp ne i8 %element_leave_4235, 0
br i1 %compare_zero_leave_4235, label %loop_body_4235, label %post_loop_4235
post_loop_4235:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4235
; >ENTER_INC_PTR 2928
%dataptr_2928 = load i32, i32* %dataptr_addr
%inc_dataptr_2928 = add i32 %dataptr_2928, 16
store i32 %inc_dataptr_2928, i32* %dataptr_addr
; <ENTER_INC_PTR 2928
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4236
%dataptr_leave_4236 = load i32, i32* %dataptr_addr
%element_addr_leave_4236 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4236
%element_leave_4236 = load i8, i8* %element_addr_leave_4236
%compare_zero_leave_4236 = icmp ne i8 %element_leave_4236, 0
br i1 %compare_zero_leave_4236, label %loop_body_4236, label %post_loop_4236
post_loop_4236:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4236
; >ENTER_DEC_PTR 2948
%dataptr_2948 = load i32, i32* %dataptr_addr
%dec_dataptr_2948 = sub i32 %dataptr_2948, 6
store i32 %dec_dataptr_2948, i32* %dataptr_addr
; <ENTER_DEC_PTR 2948
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4238
%dataptr_enter_4238 = load i32, i32* %dataptr_addr
%element_addr_enter_4238 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4238
%element_enter_4238 = load i8, i8* %element_addr_enter_4238
%compare_zero_enter_4238 = icmp eq i8 %element_enter_4238, 0
br i1 %compare_zero_enter_4238, label %post_loop_4238, label %loop_body_4238
loop_body_4238:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4238
; >ENTER_INC_PTR 2956
%dataptr_2956 = load i32, i32* %dataptr_addr
%inc_dataptr_2956 = add i32 %dataptr_2956, 3
store i32 %inc_dataptr_2956, i32* %dataptr_addr
; <ENTER_INC_PTR 2956
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4237
%dataptr_enter_4237 = load i32, i32* %dataptr_addr
%element_addr_enter_4237 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4237
%element_enter_4237 = load i8, i8* %element_addr_enter_4237
%compare_zero_enter_4237 = icmp eq i8 %element_enter_4237, 0
br i1 %compare_zero_enter_4237, label %post_loop_4237, label %loop_body_4237
loop_body_4237:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4237
; >ENTER_DEC_DATA 2960
%dataptr_2960 = load i32, i32* %dataptr_addr
%element_addr_2960 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2960
%element_2960 = load i8, i8* %element_addr_2960
%sub_element_2960 = sub i8 %element_2960, 1
store i8 %sub_element_2960, i8* %element_addr_2960
; <ENTER_DEC_DATA 2960
; >ENTER_INC_PTR 2961
%dataptr_2961 = load i32, i32* %dataptr_addr
%inc_dataptr_2961 = add i32 %dataptr_2961, 4
store i32 %inc_dataptr_2961, i32* %dataptr_addr
; <ENTER_INC_PTR 2961
; >ENTER_INC_DATA 2965
%dataptr_2965 = load i32, i32* %dataptr_addr
%element_addr_2965 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2965
%element_2965 = load i8, i8* %element_addr_2965
%inc_element_2965 = add i8 %element_2965, 1
store i8 %inc_element_2965, i8* %element_addr_2965
; <ENTER_INC_DATA 2965
; >ENTER_INC_PTR 2966
%dataptr_2966 = load i32, i32* %dataptr_addr
%inc_dataptr_2966 = add i32 %dataptr_2966, 1
store i32 %inc_dataptr_2966, i32* %dataptr_addr
; <ENTER_INC_PTR 2966
; >ENTER_INC_DATA 2967
%dataptr_2967 = load i32, i32* %dataptr_addr
%element_addr_2967 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_2967
%element_2967 = load i8, i8* %element_addr_2967
%inc_element_2967 = add i8 %element_2967, 1
store i8 %inc_element_2967, i8* %element_addr_2967
; <ENTER_INC_DATA 2967
; >ENTER_DEC_PTR 2968
%dataptr_2968 = load i32, i32* %dataptr_addr
%dec_dataptr_2968 = sub i32 %dataptr_2968, 5
store i32 %dec_dataptr_2968, i32* %dataptr_addr
; <ENTER_DEC_PTR 2968
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4237
%dataptr_leave_4237 = load i32, i32* %dataptr_addr
%element_addr_leave_4237 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4237
%element_leave_4237 = load i8, i8* %element_addr_leave_4237
%compare_zero_leave_4237 = icmp ne i8 %element_leave_4237, 0
br i1 %compare_zero_leave_4237, label %loop_body_4237, label %post_loop_4237
post_loop_4237:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4237
; >ENTER_INC_PTR 2974
%dataptr_2974 = load i32, i32* %dataptr_addr
%inc_dataptr_2974 = add i32 %dataptr_2974, 7
store i32 %inc_dataptr_2974, i32* %dataptr_addr
; <ENTER_INC_PTR 2974
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4238
%dataptr_leave_4238 = load i32, i32* %dataptr_addr
%element_addr_leave_4238 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4238
%element_leave_4238 = load i8, i8* %element_addr_leave_4238
%compare_zero_leave_4238 = icmp ne i8 %element_leave_4238, 0
br i1 %compare_zero_leave_4238, label %loop_body_4238, label %post_loop_4238
post_loop_4238:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4238
; >ENTER_DEC_PTR 2983
%dataptr_2983 = load i32, i32* %dataptr_addr
%dec_dataptr_2983 = sub i32 %dataptr_2983, 10
store i32 %dec_dataptr_2983, i32* %dataptr_addr
; <ENTER_DEC_PTR 2983
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4241
%dataptr_enter_4241 = load i32, i32* %dataptr_addr
%element_addr_enter_4241 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4241
%element_enter_4241 = load i8, i8* %element_addr_enter_4241
%compare_zero_enter_4241 = icmp eq i8 %element_enter_4241, 0
br i1 %compare_zero_enter_4241, label %post_loop_4241, label %loop_body_4241
loop_body_4241:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4241
; >ENTER_INC_PTR 2995
%dataptr_2995 = load i32, i32* %dataptr_addr
%inc_dataptr_2995 = add i32 %dataptr_2995, 7
store i32 %inc_dataptr_2995, i32* %dataptr_addr
; <ENTER_INC_PTR 2995
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4239
%dataptr_enter_4239 = load i32, i32* %dataptr_addr
%element_addr_enter_4239 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4239
%element_enter_4239 = load i8, i8* %element_addr_enter_4239
%compare_zero_enter_4239 = icmp eq i8 %element_enter_4239, 0
br i1 %compare_zero_enter_4239, label %post_loop_4239, label %loop_body_4239
loop_body_4239:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4239
; >ENTER_DEC_DATA 3003
%dataptr_3003 = load i32, i32* %dataptr_addr
%element_addr_3003 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3003
%element_3003 = load i8, i8* %element_addr_3003
%sub_element_3003 = sub i8 %element_3003, 1
store i8 %sub_element_3003, i8* %element_addr_3003
; <ENTER_DEC_DATA 3003
; >ENTER_DEC_PTR 3004
%dataptr_3004 = load i32, i32* %dataptr_addr
%dec_dataptr_3004 = sub i32 %dataptr_3004, 4
store i32 %dec_dataptr_3004, i32* %dataptr_addr
; <ENTER_DEC_PTR 3004
; >ENTER_INC_DATA 3008
%dataptr_3008 = load i32, i32* %dataptr_addr
%element_addr_3008 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3008
%element_3008 = load i8, i8* %element_addr_3008
%inc_element_3008 = add i8 %element_3008, 1
store i8 %inc_element_3008, i8* %element_addr_3008
; <ENTER_INC_DATA 3008
; >ENTER_INC_PTR 3009
%dataptr_3009 = load i32, i32* %dataptr_addr
%inc_dataptr_3009 = add i32 %dataptr_3009, 4
store i32 %inc_dataptr_3009, i32* %dataptr_addr
; <ENTER_INC_PTR 3009
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4239
%dataptr_leave_4239 = load i32, i32* %dataptr_addr
%element_addr_leave_4239 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4239
%element_leave_4239 = load i8, i8* %element_addr_leave_4239
%compare_zero_leave_4239 = icmp ne i8 %element_leave_4239, 0
br i1 %compare_zero_leave_4239, label %loop_body_4239, label %post_loop_4239
post_loop_4239:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4239
; >ENTER_DEC_PTR 3014
%dataptr_3014 = load i32, i32* %dataptr_addr
%dec_dataptr_3014 = sub i32 %dataptr_3014, 5
store i32 %dec_dataptr_3014, i32* %dataptr_addr
; <ENTER_DEC_PTR 3014
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4240
%dataptr_enter_4240 = load i32, i32* %dataptr_addr
%element_addr_enter_4240 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4240
%element_enter_4240 = load i8, i8* %element_addr_enter_4240
%compare_zero_enter_4240 = icmp eq i8 %element_enter_4240, 0
br i1 %compare_zero_enter_4240, label %post_loop_4240, label %loop_body_4240
loop_body_4240:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4240
; >ENTER_DEC_DATA 3020
%dataptr_3020 = load i32, i32* %dataptr_addr
%element_addr_3020 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3020
%element_3020 = load i8, i8* %element_addr_3020
%sub_element_3020 = sub i8 %element_3020, 1
store i8 %sub_element_3020, i8* %element_addr_3020
; <ENTER_DEC_DATA 3020
; >ENTER_INC_PTR 3021
%dataptr_3021 = load i32, i32* %dataptr_addr
%inc_dataptr_3021 = add i32 %dataptr_3021, 5
store i32 %inc_dataptr_3021, i32* %dataptr_addr
; <ENTER_INC_PTR 3021
; >ENTER_INC_DATA 3026
%dataptr_3026 = load i32, i32* %dataptr_addr
%element_addr_3026 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3026
%element_3026 = load i8, i8* %element_addr_3026
%inc_element_3026 = add i8 %element_3026, 1
store i8 %inc_element_3026, i8* %element_addr_3026
; <ENTER_INC_DATA 3026
; >ENTER_INC_PTR 3027
%dataptr_3027 = load i32, i32* %dataptr_addr
%inc_dataptr_3027 = add i32 %dataptr_3027, 2
store i32 %inc_dataptr_3027, i32* %dataptr_addr
; <ENTER_INC_PTR 3027
; >ENTER_INC_DATA 3029
%dataptr_3029 = load i32, i32* %dataptr_addr
%element_addr_3029 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3029
%element_3029 = load i8, i8* %element_addr_3029
%inc_element_3029 = add i8 %element_3029, 1
store i8 %inc_element_3029, i8* %element_addr_3029
; <ENTER_INC_DATA 3029
; >ENTER_DEC_PTR 3030
%dataptr_3030 = load i32, i32* %dataptr_addr
%dec_dataptr_3030 = sub i32 %dataptr_3030, 7
store i32 %dec_dataptr_3030, i32* %dataptr_addr
; <ENTER_DEC_PTR 3030
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4240
%dataptr_leave_4240 = load i32, i32* %dataptr_addr
%element_addr_leave_4240 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4240
%element_leave_4240 = load i8, i8* %element_addr_leave_4240
%compare_zero_leave_4240 = icmp ne i8 %element_leave_4240, 0
br i1 %compare_zero_leave_4240, label %loop_body_4240, label %post_loop_4240
post_loop_4240:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4240
; >ENTER_DEC_PTR 3038
%dataptr_3038 = load i32, i32* %dataptr_addr
%dec_dataptr_3038 = sub i32 %dataptr_3038, 12
store i32 %dec_dataptr_3038, i32* %dataptr_addr
; <ENTER_DEC_PTR 3038
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4241
%dataptr_leave_4241 = load i32, i32* %dataptr_addr
%element_addr_leave_4241 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4241
%element_leave_4241 = load i8, i8* %element_addr_leave_4241
%compare_zero_leave_4241 = icmp ne i8 %element_leave_4241, 0
br i1 %compare_zero_leave_4241, label %loop_body_4241, label %post_loop_4241
post_loop_4241:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4241
; >ENTER_INC_PTR 3052
%dataptr_3052 = load i32, i32* %dataptr_addr
%inc_dataptr_3052 = add i32 %dataptr_3052, 10
store i32 %inc_dataptr_3052, i32* %dataptr_addr
; <ENTER_INC_PTR 3052
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4243
%dataptr_enter_4243 = load i32, i32* %dataptr_addr
%element_addr_enter_4243 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4243
%element_enter_4243 = load i8, i8* %element_addr_enter_4243
%compare_zero_enter_4243 = icmp eq i8 %element_enter_4243, 0
br i1 %compare_zero_enter_4243, label %post_loop_4243, label %loop_body_4243
loop_body_4243:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4243
; >ENTER_INC_PTR 3063
%dataptr_3063 = load i32, i32* %dataptr_addr
%inc_dataptr_3063 = add i32 %dataptr_3063, 7
store i32 %inc_dataptr_3063, i32* %dataptr_addr
; <ENTER_INC_PTR 3063
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4242
%dataptr_enter_4242 = load i32, i32* %dataptr_addr
%element_addr_enter_4242 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4242
%element_enter_4242 = load i8, i8* %element_addr_enter_4242
%compare_zero_enter_4242 = icmp eq i8 %element_enter_4242, 0
br i1 %compare_zero_enter_4242, label %post_loop_4242, label %loop_body_4242
loop_body_4242:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4242
; >ENTER_DEC_DATA 3071
%dataptr_3071 = load i32, i32* %dataptr_addr
%element_addr_3071 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3071
%element_3071 = load i8, i8* %element_addr_3071
%sub_element_3071 = sub i8 %element_3071, 1
store i8 %sub_element_3071, i8* %element_addr_3071
; <ENTER_DEC_DATA 3071
; >ENTER_DEC_PTR 3072
%dataptr_3072 = load i32, i32* %dataptr_addr
%dec_dataptr_3072 = sub i32 %dataptr_3072, 5
store i32 %dec_dataptr_3072, i32* %dataptr_addr
; <ENTER_DEC_PTR 3072
; >ENTER_INC_DATA 3077
%dataptr_3077 = load i32, i32* %dataptr_addr
%element_addr_3077 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3077
%element_3077 = load i8, i8* %element_addr_3077
%inc_element_3077 = add i8 %element_3077, 1
store i8 %inc_element_3077, i8* %element_addr_3077
; <ENTER_INC_DATA 3077
; >ENTER_INC_PTR 3078
%dataptr_3078 = load i32, i32* %dataptr_addr
%inc_dataptr_3078 = add i32 %dataptr_3078, 5
store i32 %inc_dataptr_3078, i32* %dataptr_addr
; <ENTER_INC_PTR 3078
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4242
%dataptr_leave_4242 = load i32, i32* %dataptr_addr
%element_addr_leave_4242 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4242
%element_leave_4242 = load i8, i8* %element_addr_leave_4242
%compare_zero_leave_4242 = icmp ne i8 %element_leave_4242, 0
br i1 %compare_zero_leave_4242, label %loop_body_4242, label %post_loop_4242
post_loop_4242:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4242
; >ENTER_INC_PTR 3084
%dataptr_3084 = load i32, i32* %dataptr_addr
%inc_dataptr_3084 = add i32 %dataptr_3084, 3
store i32 %inc_dataptr_3084, i32* %dataptr_addr
; <ENTER_INC_PTR 3084
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4243
%dataptr_leave_4243 = load i32, i32* %dataptr_addr
%element_addr_leave_4243 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4243
%element_leave_4243 = load i8, i8* %element_addr_leave_4243
%compare_zero_leave_4243 = icmp ne i8 %element_leave_4243, 0
br i1 %compare_zero_leave_4243, label %loop_body_4243, label %post_loop_4243
post_loop_4243:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4243
; >ENTER_DEC_PTR 3088
%dataptr_3088 = load i32, i32* %dataptr_addr
%dec_dataptr_3088 = sub i32 %dataptr_3088, 10
store i32 %dec_dataptr_3088, i32* %dataptr_addr
; <ENTER_DEC_PTR 3088
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4249
%dataptr_enter_4249 = load i32, i32* %dataptr_addr
%element_addr_enter_4249 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4249
%element_enter_4249 = load i8, i8* %element_addr_enter_4249
%compare_zero_enter_4249 = icmp eq i8 %element_enter_4249, 0
br i1 %compare_zero_enter_4249, label %post_loop_4249, label %loop_body_4249
loop_body_4249:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4249
; >ENTER_INC_PTR 3100
%dataptr_3100 = load i32, i32* %dataptr_addr
%inc_dataptr_3100 = add i32 %dataptr_3100, 9
store i32 %inc_dataptr_3100, i32* %dataptr_addr
; <ENTER_INC_PTR 3100
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4244
%dataptr_enter_4244 = load i32, i32* %dataptr_addr
%element_addr_enter_4244 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4244
%element_enter_4244 = load i8, i8* %element_addr_enter_4244
%compare_zero_enter_4244 = icmp eq i8 %element_enter_4244, 0
br i1 %compare_zero_enter_4244, label %post_loop_4244, label %loop_body_4244
loop_body_4244:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4244
; >ENTER_DEC_DATA 3110
%dataptr_3110 = load i32, i32* %dataptr_addr
%element_addr_3110 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3110
%element_3110 = load i8, i8* %element_addr_3110
%sub_element_3110 = sub i8 %element_3110, 1
store i8 %sub_element_3110, i8* %element_addr_3110
; <ENTER_DEC_DATA 3110
; >ENTER_DEC_PTR 3111
%dataptr_3111 = load i32, i32* %dataptr_addr
%dec_dataptr_3111 = sub i32 %dataptr_3111, 1
store i32 %dec_dataptr_3111, i32* %dataptr_addr
; <ENTER_DEC_PTR 3111
; >ENTER_DEC_DATA 3112
%dataptr_3112 = load i32, i32* %dataptr_addr
%element_addr_3112 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3112
%element_3112 = load i8, i8* %element_addr_3112
%sub_element_3112 = sub i8 %element_3112, 1
store i8 %sub_element_3112, i8* %element_addr_3112
; <ENTER_DEC_DATA 3112
; >ENTER_INC_PTR 3113
%dataptr_3113 = load i32, i32* %dataptr_addr
%inc_dataptr_3113 = add i32 %dataptr_3113, 1
store i32 %inc_dataptr_3113, i32* %dataptr_addr
; <ENTER_INC_PTR 3113
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4244
%dataptr_leave_4244 = load i32, i32* %dataptr_addr
%element_addr_leave_4244 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4244
%element_leave_4244 = load i8, i8* %element_addr_leave_4244
%compare_zero_leave_4244 = icmp ne i8 %element_leave_4244, 0
br i1 %compare_zero_leave_4244, label %loop_body_4244, label %post_loop_4244
post_loop_4244:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4244
; >ENTER_DEC_PTR 3115
%dataptr_3115 = load i32, i32* %dataptr_addr
%dec_dataptr_3115 = sub i32 %dataptr_3115, 1
store i32 %dec_dataptr_3115, i32* %dataptr_addr
; <ENTER_DEC_PTR 3115
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4248
%dataptr_enter_4248 = load i32, i32* %dataptr_addr
%element_addr_enter_4248 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4248
%element_enter_4248 = load i8, i8* %element_addr_enter_4248
%compare_zero_enter_4248 = icmp eq i8 %element_enter_4248, 0
br i1 %compare_zero_enter_4248, label %post_loop_4248, label %loop_body_4248
loop_body_4248:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4248
; >ENTER_DEC_PTR 3118
%dataptr_3118 = load i32, i32* %dataptr_addr
%dec_dataptr_3118 = sub i32 %dataptr_3118, 8
store i32 %dec_dataptr_3118, i32* %dataptr_addr
; <ENTER_DEC_PTR 3118
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4247
%dataptr_enter_4247 = load i32, i32* %dataptr_addr
%element_addr_enter_4247 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4247
%element_enter_4247 = load i8, i8* %element_addr_enter_4247
%compare_zero_enter_4247 = icmp eq i8 %element_enter_4247, 0
br i1 %compare_zero_enter_4247, label %post_loop_4247, label %loop_body_4247
loop_body_4247:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4247
; >ENTER_DEC_PTR 3128
%dataptr_3128 = load i32, i32* %dataptr_addr
%dec_dataptr_3128 = sub i32 %dataptr_3128, 2
store i32 %dec_dataptr_3128, i32* %dataptr_addr
; <ENTER_DEC_PTR 3128
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4245
%dataptr_enter_4245 = load i32, i32* %dataptr_addr
%element_addr_enter_4245 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4245
%element_enter_4245 = load i8, i8* %element_addr_enter_4245
%compare_zero_enter_4245 = icmp eq i8 %element_enter_4245, 0
br i1 %compare_zero_enter_4245, label %post_loop_4245, label %loop_body_4245
loop_body_4245:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4245
; >ENTER_DEC_DATA 3131
%dataptr_3131 = load i32, i32* %dataptr_addr
%element_addr_3131 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3131
%element_3131 = load i8, i8* %element_addr_3131
%sub_element_3131 = sub i8 %element_3131, 1
store i8 %sub_element_3131, i8* %element_addr_3131
; <ENTER_DEC_DATA 3131
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4245
%dataptr_leave_4245 = load i32, i32* %dataptr_addr
%element_addr_leave_4245 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4245
%element_leave_4245 = load i8, i8* %element_addr_leave_4245
%compare_zero_leave_4245 = icmp ne i8 %element_leave_4245, 0
br i1 %compare_zero_leave_4245, label %loop_body_4245, label %post_loop_4245
post_loop_4245:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4245
; >ENTER_INC_PTR 3133
%dataptr_3133 = load i32, i32* %dataptr_addr
%inc_dataptr_3133 = add i32 %dataptr_3133, 10
store i32 %inc_dataptr_3133, i32* %dataptr_addr
; <ENTER_INC_PTR 3133
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4246
%dataptr_enter_4246 = load i32, i32* %dataptr_addr
%element_addr_enter_4246 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4246
%element_enter_4246 = load i8, i8* %element_addr_enter_4246
%compare_zero_enter_4246 = icmp eq i8 %element_enter_4246, 0
br i1 %compare_zero_enter_4246, label %post_loop_4246, label %loop_body_4246
loop_body_4246:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4246
; >ENTER_DEC_DATA 3144
%dataptr_3144 = load i32, i32* %dataptr_addr
%element_addr_3144 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3144
%element_3144 = load i8, i8* %element_addr_3144
%sub_element_3144 = sub i8 %element_3144, 1
store i8 %sub_element_3144, i8* %element_addr_3144
; <ENTER_DEC_DATA 3144
; >ENTER_DEC_PTR 3145
%dataptr_3145 = load i32, i32* %dataptr_addr
%dec_dataptr_3145 = sub i32 %dataptr_3145, 10
store i32 %dec_dataptr_3145, i32* %dataptr_addr
; <ENTER_DEC_PTR 3145
; >ENTER_INC_DATA 3155
%dataptr_3155 = load i32, i32* %dataptr_addr
%element_addr_3155 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3155
%element_3155 = load i8, i8* %element_addr_3155
%inc_element_3155 = add i8 %element_3155, 1
store i8 %inc_element_3155, i8* %element_addr_3155
; <ENTER_INC_DATA 3155
; >ENTER_INC_PTR 3156
%dataptr_3156 = load i32, i32* %dataptr_addr
%inc_dataptr_3156 = add i32 %dataptr_3156, 10
store i32 %inc_dataptr_3156, i32* %dataptr_addr
; <ENTER_INC_PTR 3156
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4246
%dataptr_leave_4246 = load i32, i32* %dataptr_addr
%element_addr_leave_4246 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4246
%element_leave_4246 = load i8, i8* %element_addr_leave_4246
%compare_zero_leave_4246 = icmp ne i8 %element_leave_4246, 0
br i1 %compare_zero_leave_4246, label %loop_body_4246, label %post_loop_4246
post_loop_4246:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4246
; >ENTER_DEC_PTR 3167
%dataptr_3167 = load i32, i32* %dataptr_addr
%dec_dataptr_3167 = sub i32 %dataptr_3167, 18
store i32 %dec_dataptr_3167, i32* %dataptr_addr
; <ENTER_DEC_PTR 3167
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4247
%dataptr_leave_4247 = load i32, i32* %dataptr_addr
%element_addr_leave_4247 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4247
%element_leave_4247 = load i8, i8* %element_addr_leave_4247
%compare_zero_leave_4247 = icmp ne i8 %element_leave_4247, 0
br i1 %compare_zero_leave_4247, label %loop_body_4247, label %post_loop_4247
post_loop_4247:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4247
; >ENTER_INC_PTR 3187
%dataptr_3187 = load i32, i32* %dataptr_addr
%inc_dataptr_3187 = add i32 %dataptr_3187, 18
store i32 %inc_dataptr_3187, i32* %dataptr_addr
; <ENTER_INC_PTR 3187
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4248
%dataptr_leave_4248 = load i32, i32* %dataptr_addr
%element_addr_leave_4248 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4248
%element_leave_4248 = load i8, i8* %element_addr_leave_4248
%compare_zero_leave_4248 = icmp ne i8 %element_leave_4248, 0
br i1 %compare_zero_leave_4248, label %loop_body_4248, label %post_loop_4248
post_loop_4248:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4248
; >ENTER_DEC_PTR 3206
%dataptr_3206 = load i32, i32* %dataptr_addr
%dec_dataptr_3206 = sub i32 %dataptr_3206, 18
store i32 %dec_dataptr_3206, i32* %dataptr_addr
; <ENTER_DEC_PTR 3206
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4249
%dataptr_leave_4249 = load i32, i32* %dataptr_addr
%element_addr_leave_4249 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4249
%element_leave_4249 = load i8, i8* %element_addr_leave_4249
%compare_zero_leave_4249 = icmp ne i8 %element_leave_4249, 0
br i1 %compare_zero_leave_4249, label %loop_body_4249, label %post_loop_4249
post_loop_4249:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4249
; >ENTER_INC_PTR 3226
%dataptr_3226 = load i32, i32* %dataptr_addr
%inc_dataptr_3226 = add i32 %dataptr_3226, 8
store i32 %inc_dataptr_3226, i32* %dataptr_addr
; <ENTER_INC_PTR 3226
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4261
%dataptr_enter_4261 = load i32, i32* %dataptr_addr
%element_addr_enter_4261 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4261
%element_enter_4261 = load i8, i8* %element_addr_enter_4261
%compare_zero_enter_4261 = icmp eq i8 %element_enter_4261, 0
br i1 %compare_zero_enter_4261, label %post_loop_4261, label %loop_body_4261
loop_body_4261:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4261
; >ENTER_INC_PTR 3235
%dataptr_3235 = load i32, i32* %dataptr_addr
%inc_dataptr_3235 = add i32 %dataptr_3235, 1
store i32 %inc_dataptr_3235, i32* %dataptr_addr
; <ENTER_INC_PTR 3235
; >ENTER_DEC_DATA 3236
%dataptr_3236 = load i32, i32* %dataptr_addr
%element_addr_3236 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3236
%element_3236 = load i8, i8* %element_addr_3236
%sub_element_3236 = sub i8 %element_3236, 1
store i8 %sub_element_3236, i8* %element_addr_3236
; <ENTER_DEC_DATA 3236
; >ENTER_DEC_PTR 3237
%dataptr_3237 = load i32, i32* %dataptr_addr
%dec_dataptr_3237 = sub i32 %dataptr_3237, 1
store i32 %dec_dataptr_3237, i32* %dataptr_addr
; <ENTER_DEC_PTR 3237
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4260
%dataptr_enter_4260 = load i32, i32* %dataptr_addr
%element_addr_enter_4260 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4260
%element_enter_4260 = load i8, i8* %element_addr_enter_4260
%compare_zero_enter_4260 = icmp eq i8 %element_enter_4260, 0
br i1 %compare_zero_enter_4260, label %post_loop_4260, label %loop_body_4260
loop_body_4260:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4260
; >ENTER_INC_DATA 3239
%dataptr_3239 = load i32, i32* %dataptr_addr
%element_addr_3239 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3239
%element_3239 = load i8, i8* %element_addr_3239
%inc_element_3239 = add i8 %element_3239, 1
store i8 %inc_element_3239, i8* %element_addr_3239
; <ENTER_INC_DATA 3239
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4259
%dataptr_enter_4259 = load i32, i32* %dataptr_addr
%element_addr_enter_4259 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4259
%element_enter_4259 = load i8, i8* %element_addr_enter_4259
%compare_zero_enter_4259 = icmp eq i8 %element_enter_4259, 0
br i1 %compare_zero_enter_4259, label %post_loop_4259, label %loop_body_4259
loop_body_4259:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4259
; >ENTER_INC_DATA 3241
%dataptr_3241 = load i32, i32* %dataptr_addr
%element_addr_3241 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3241
%element_3241 = load i8, i8* %element_addr_3241
%inc_element_3241 = add i8 %element_3241, 1
store i8 %inc_element_3241, i8* %element_addr_3241
; <ENTER_INC_DATA 3241
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4258
%dataptr_enter_4258 = load i32, i32* %dataptr_addr
%element_addr_enter_4258 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4258
%element_enter_4258 = load i8, i8* %element_addr_enter_4258
%compare_zero_enter_4258 = icmp eq i8 %element_enter_4258, 0
br i1 %compare_zero_enter_4258, label %post_loop_4258, label %loop_body_4258
loop_body_4258:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4258
; >ENTER_INC_DATA 3243
%dataptr_3243 = load i32, i32* %dataptr_addr
%element_addr_3243 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3243
%element_3243 = load i8, i8* %element_addr_3243
%inc_element_3243 = add i8 %element_3243, 1
store i8 %inc_element_3243, i8* %element_addr_3243
; <ENTER_INC_DATA 3243
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4257
%dataptr_enter_4257 = load i32, i32* %dataptr_addr
%element_addr_enter_4257 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4257
%element_enter_4257 = load i8, i8* %element_addr_enter_4257
%compare_zero_enter_4257 = icmp eq i8 %element_enter_4257, 0
br i1 %compare_zero_enter_4257, label %post_loop_4257, label %loop_body_4257
loop_body_4257:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4257
; >ENTER_INC_DATA 3245
%dataptr_3245 = load i32, i32* %dataptr_addr
%element_addr_3245 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3245
%element_3245 = load i8, i8* %element_addr_3245
%inc_element_3245 = add i8 %element_3245, 1
store i8 %inc_element_3245, i8* %element_addr_3245
; <ENTER_INC_DATA 3245
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4256
%dataptr_enter_4256 = load i32, i32* %dataptr_addr
%element_addr_enter_4256 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4256
%element_enter_4256 = load i8, i8* %element_addr_enter_4256
%compare_zero_enter_4256 = icmp eq i8 %element_enter_4256, 0
br i1 %compare_zero_enter_4256, label %post_loop_4256, label %loop_body_4256
loop_body_4256:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4256
; >ENTER_INC_DATA 3247
%dataptr_3247 = load i32, i32* %dataptr_addr
%element_addr_3247 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3247
%element_3247 = load i8, i8* %element_addr_3247
%inc_element_3247 = add i8 %element_3247, 1
store i8 %inc_element_3247, i8* %element_addr_3247
; <ENTER_INC_DATA 3247
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4255
%dataptr_enter_4255 = load i32, i32* %dataptr_addr
%element_addr_enter_4255 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4255
%element_enter_4255 = load i8, i8* %element_addr_enter_4255
%compare_zero_enter_4255 = icmp eq i8 %element_enter_4255, 0
br i1 %compare_zero_enter_4255, label %post_loop_4255, label %loop_body_4255
loop_body_4255:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4255
; >ENTER_INC_DATA 3249
%dataptr_3249 = load i32, i32* %dataptr_addr
%element_addr_3249 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3249
%element_3249 = load i8, i8* %element_addr_3249
%inc_element_3249 = add i8 %element_3249, 1
store i8 %inc_element_3249, i8* %element_addr_3249
; <ENTER_INC_DATA 3249
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4254
%dataptr_enter_4254 = load i32, i32* %dataptr_addr
%element_addr_enter_4254 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4254
%element_enter_4254 = load i8, i8* %element_addr_enter_4254
%compare_zero_enter_4254 = icmp eq i8 %element_enter_4254, 0
br i1 %compare_zero_enter_4254, label %post_loop_4254, label %loop_body_4254
loop_body_4254:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4254
; >ENTER_INC_DATA 3251
%dataptr_3251 = load i32, i32* %dataptr_addr
%element_addr_3251 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3251
%element_3251 = load i8, i8* %element_addr_3251
%inc_element_3251 = add i8 %element_3251, 1
store i8 %inc_element_3251, i8* %element_addr_3251
; <ENTER_INC_DATA 3251
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4253
%dataptr_enter_4253 = load i32, i32* %dataptr_addr
%element_addr_enter_4253 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4253
%element_enter_4253 = load i8, i8* %element_addr_enter_4253
%compare_zero_enter_4253 = icmp eq i8 %element_enter_4253, 0
br i1 %compare_zero_enter_4253, label %post_loop_4253, label %loop_body_4253
loop_body_4253:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4253
; >ENTER_INC_DATA 3253
%dataptr_3253 = load i32, i32* %dataptr_addr
%element_addr_3253 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3253
%element_3253 = load i8, i8* %element_addr_3253
%inc_element_3253 = add i8 %element_3253, 1
store i8 %inc_element_3253, i8* %element_addr_3253
; <ENTER_INC_DATA 3253
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4252
%dataptr_enter_4252 = load i32, i32* %dataptr_addr
%element_addr_enter_4252 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4252
%element_enter_4252 = load i8, i8* %element_addr_enter_4252
%compare_zero_enter_4252 = icmp eq i8 %element_enter_4252, 0
br i1 %compare_zero_enter_4252, label %post_loop_4252, label %loop_body_4252
loop_body_4252:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4252
; >ENTER_INC_DATA 3255
%dataptr_3255 = load i32, i32* %dataptr_addr
%element_addr_3255 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3255
%element_3255 = load i8, i8* %element_addr_3255
%inc_element_3255 = add i8 %element_3255, 1
store i8 %inc_element_3255, i8* %element_addr_3255
; <ENTER_INC_DATA 3255
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4251
%dataptr_enter_4251 = load i32, i32* %dataptr_addr
%element_addr_enter_4251 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4251
%element_enter_4251 = load i8, i8* %element_addr_enter_4251
%compare_zero_enter_4251 = icmp eq i8 %element_enter_4251, 0
br i1 %compare_zero_enter_4251, label %post_loop_4251, label %loop_body_4251
loop_body_4251:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4251
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4250
%dataptr_enter_4250 = load i32, i32* %dataptr_addr
%element_addr_enter_4250 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4250
%element_enter_4250 = load i8, i8* %element_addr_enter_4250
%compare_zero_enter_4250 = icmp eq i8 %element_enter_4250, 0
br i1 %compare_zero_enter_4250, label %post_loop_4250, label %loop_body_4250
loop_body_4250:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4250
; >ENTER_DEC_DATA 3258
%dataptr_3258 = load i32, i32* %dataptr_addr
%element_addr_3258 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3258
%element_3258 = load i8, i8* %element_addr_3258
%sub_element_3258 = sub i8 %element_3258, 1
store i8 %sub_element_3258, i8* %element_addr_3258
; <ENTER_DEC_DATA 3258
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4250
%dataptr_leave_4250 = load i32, i32* %dataptr_addr
%element_addr_leave_4250 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4250
%element_leave_4250 = load i8, i8* %element_addr_leave_4250
%compare_zero_leave_4250 = icmp ne i8 %element_leave_4250, 0
br i1 %compare_zero_leave_4250, label %loop_body_4250, label %post_loop_4250
post_loop_4250:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4250
; >ENTER_INC_PTR 3260
%dataptr_3260 = load i32, i32* %dataptr_addr
%inc_dataptr_3260 = add i32 %dataptr_3260, 1
store i32 %inc_dataptr_3260, i32* %dataptr_addr
; <ENTER_INC_PTR 3260
; >ENTER_INC_DATA 3261
%dataptr_3261 = load i32, i32* %dataptr_addr
%element_addr_3261 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3261
%element_3261 = load i8, i8* %element_addr_3261
%inc_element_3261 = add i8 %element_3261, 1
store i8 %inc_element_3261, i8* %element_addr_3261
; <ENTER_INC_DATA 3261
; >ENTER_DEC_PTR 3262
%dataptr_3262 = load i32, i32* %dataptr_addr
%dec_dataptr_3262 = sub i32 %dataptr_3262, 1
store i32 %dec_dataptr_3262, i32* %dataptr_addr
; <ENTER_DEC_PTR 3262
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4251
%dataptr_leave_4251 = load i32, i32* %dataptr_addr
%element_addr_leave_4251 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4251
%element_leave_4251 = load i8, i8* %element_addr_leave_4251
%compare_zero_leave_4251 = icmp ne i8 %element_leave_4251, 0
br i1 %compare_zero_leave_4251, label %loop_body_4251, label %post_loop_4251
post_loop_4251:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4251
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4252
%dataptr_leave_4252 = load i32, i32* %dataptr_addr
%element_addr_leave_4252 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4252
%element_leave_4252 = load i8, i8* %element_addr_leave_4252
%compare_zero_leave_4252 = icmp ne i8 %element_leave_4252, 0
br i1 %compare_zero_leave_4252, label %loop_body_4252, label %post_loop_4252
post_loop_4252:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4252
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4253
%dataptr_leave_4253 = load i32, i32* %dataptr_addr
%element_addr_leave_4253 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4253
%element_leave_4253 = load i8, i8* %element_addr_leave_4253
%compare_zero_leave_4253 = icmp ne i8 %element_leave_4253, 0
br i1 %compare_zero_leave_4253, label %loop_body_4253, label %post_loop_4253
post_loop_4253:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4253
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4254
%dataptr_leave_4254 = load i32, i32* %dataptr_addr
%element_addr_leave_4254 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4254
%element_leave_4254 = load i8, i8* %element_addr_leave_4254
%compare_zero_leave_4254 = icmp ne i8 %element_leave_4254, 0
br i1 %compare_zero_leave_4254, label %loop_body_4254, label %post_loop_4254
post_loop_4254:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4254
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4255
%dataptr_leave_4255 = load i32, i32* %dataptr_addr
%element_addr_leave_4255 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4255
%element_leave_4255 = load i8, i8* %element_addr_leave_4255
%compare_zero_leave_4255 = icmp ne i8 %element_leave_4255, 0
br i1 %compare_zero_leave_4255, label %loop_body_4255, label %post_loop_4255
post_loop_4255:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4255
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4256
%dataptr_leave_4256 = load i32, i32* %dataptr_addr
%element_addr_leave_4256 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4256
%element_leave_4256 = load i8, i8* %element_addr_leave_4256
%compare_zero_leave_4256 = icmp ne i8 %element_leave_4256, 0
br i1 %compare_zero_leave_4256, label %loop_body_4256, label %post_loop_4256
post_loop_4256:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4256
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4257
%dataptr_leave_4257 = load i32, i32* %dataptr_addr
%element_addr_leave_4257 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4257
%element_leave_4257 = load i8, i8* %element_addr_leave_4257
%compare_zero_leave_4257 = icmp ne i8 %element_leave_4257, 0
br i1 %compare_zero_leave_4257, label %loop_body_4257, label %post_loop_4257
post_loop_4257:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4257
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4258
%dataptr_leave_4258 = load i32, i32* %dataptr_addr
%element_addr_leave_4258 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4258
%element_leave_4258 = load i8, i8* %element_addr_leave_4258
%compare_zero_leave_4258 = icmp ne i8 %element_leave_4258, 0
br i1 %compare_zero_leave_4258, label %loop_body_4258, label %post_loop_4258
post_loop_4258:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4258
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4259
%dataptr_leave_4259 = load i32, i32* %dataptr_addr
%element_addr_leave_4259 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4259
%element_leave_4259 = load i8, i8* %element_addr_leave_4259
%compare_zero_leave_4259 = icmp ne i8 %element_leave_4259, 0
br i1 %compare_zero_leave_4259, label %loop_body_4259, label %post_loop_4259
post_loop_4259:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4259
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4260
%dataptr_leave_4260 = load i32, i32* %dataptr_addr
%element_addr_leave_4260 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4260
%element_leave_4260 = load i8, i8* %element_addr_leave_4260
%compare_zero_leave_4260 = icmp ne i8 %element_leave_4260, 0
br i1 %compare_zero_leave_4260, label %loop_body_4260, label %post_loop_4260
post_loop_4260:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4260
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4261
%dataptr_leave_4261 = load i32, i32* %dataptr_addr
%element_addr_leave_4261 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4261
%element_leave_4261 = load i8, i8* %element_addr_leave_4261
%compare_zero_leave_4261 = icmp ne i8 %element_leave_4261, 0
br i1 %compare_zero_leave_4261, label %loop_body_4261, label %post_loop_4261
post_loop_4261:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4261
; >ENTER_INC_PTR 3274
%dataptr_3274 = load i32, i32* %dataptr_addr
%inc_dataptr_3274 = add i32 %dataptr_3274, 1
store i32 %inc_dataptr_3274, i32* %dataptr_addr
; <ENTER_INC_PTR 3274
; >ENTER_INC_DATA 3275
%dataptr_3275 = load i32, i32* %dataptr_addr
%element_addr_3275 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3275
%element_3275 = load i8, i8* %element_addr_3275
%inc_element_3275 = add i8 %element_3275, 1
store i8 %inc_element_3275, i8* %element_addr_3275
; <ENTER_INC_DATA 3275
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4293
%dataptr_enter_4293 = load i32, i32* %dataptr_addr
%element_addr_enter_4293 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4293
%element_enter_4293 = load i8, i8* %element_addr_enter_4293
%compare_zero_enter_4293 = icmp eq i8 %element_enter_4293, 0
br i1 %compare_zero_enter_4293, label %post_loop_4293, label %loop_body_4293
loop_body_4293:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4293
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4262
%dataptr_enter_4262 = load i32, i32* %dataptr_addr
%element_addr_enter_4262 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4262
%element_enter_4262 = load i8, i8* %element_addr_enter_4262
%compare_zero_enter_4262 = icmp eq i8 %element_enter_4262, 0
br i1 %compare_zero_enter_4262, label %post_loop_4262, label %loop_body_4262
loop_body_4262:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4262
; >ENTER_DEC_DATA 3280
%dataptr_3280 = load i32, i32* %dataptr_addr
%element_addr_3280 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3280
%element_3280 = load i8, i8* %element_addr_3280
%sub_element_3280 = sub i8 %element_3280, 1
store i8 %sub_element_3280, i8* %element_addr_3280
; <ENTER_DEC_DATA 3280
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4262
%dataptr_leave_4262 = load i32, i32* %dataptr_addr
%element_addr_leave_4262 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4262
%element_leave_4262 = load i8, i8* %element_addr_leave_4262
%compare_zero_leave_4262 = icmp ne i8 %element_leave_4262, 0
br i1 %compare_zero_leave_4262, label %loop_body_4262, label %post_loop_4262
post_loop_4262:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4262
; >ENTER_DEC_PTR 3283
%dataptr_3283 = load i32, i32* %dataptr_addr
%dec_dataptr_3283 = sub i32 %dataptr_3283, 1
store i32 %dec_dataptr_3283, i32* %dataptr_addr
; <ENTER_DEC_PTR 3283
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4263
%dataptr_enter_4263 = load i32, i32* %dataptr_addr
%element_addr_enter_4263 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4263
%element_enter_4263 = load i8, i8* %element_addr_enter_4263
%compare_zero_enter_4263 = icmp eq i8 %element_enter_4263, 0
br i1 %compare_zero_enter_4263, label %post_loop_4263, label %loop_body_4263
loop_body_4263:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4263
; >ENTER_DEC_DATA 3285
%dataptr_3285 = load i32, i32* %dataptr_addr
%element_addr_3285 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3285
%element_3285 = load i8, i8* %element_addr_3285
%sub_element_3285 = sub i8 %element_3285, 1
store i8 %sub_element_3285, i8* %element_addr_3285
; <ENTER_DEC_DATA 3285
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4263
%dataptr_leave_4263 = load i32, i32* %dataptr_addr
%element_addr_leave_4263 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4263
%element_leave_4263 = load i8, i8* %element_addr_leave_4263
%compare_zero_leave_4263 = icmp ne i8 %element_leave_4263, 0
br i1 %compare_zero_leave_4263, label %loop_body_4263, label %post_loop_4263
post_loop_4263:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4263
; >ENTER_INC_DATA 3287
%dataptr_3287 = load i32, i32* %dataptr_addr
%element_addr_3287 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3287
%element_3287 = load i8, i8* %element_addr_3287
%inc_element_3287 = add i8 %element_3287, 1
store i8 %inc_element_3287, i8* %element_addr_3287
; <ENTER_INC_DATA 3287
; >ENTER_INC_PTR 3288
%dataptr_3288 = load i32, i32* %dataptr_addr
%inc_dataptr_3288 = add i32 %dataptr_3288, 4
store i32 %inc_dataptr_3288, i32* %dataptr_addr
; <ENTER_INC_PTR 3288
; >ENTER_INC_DATA 3292
%dataptr_3292 = load i32, i32* %dataptr_addr
%element_addr_3292 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3292
%element_3292 = load i8, i8* %element_addr_3292
%inc_element_3292 = add i8 %element_3292, 1
store i8 %inc_element_3292, i8* %element_addr_3292
; <ENTER_INC_DATA 3292
; >ENTER_INC_PTR 3293
%dataptr_3293 = load i32, i32* %dataptr_addr
%inc_dataptr_3293 = add i32 %dataptr_3293, 8
store i32 %inc_dataptr_3293, i32* %dataptr_addr
; <ENTER_INC_PTR 3293
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4264
%dataptr_enter_4264 = load i32, i32* %dataptr_addr
%element_addr_enter_4264 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4264
%element_enter_4264 = load i8, i8* %element_addr_enter_4264
%compare_zero_enter_4264 = icmp eq i8 %element_enter_4264, 0
br i1 %compare_zero_enter_4264, label %post_loop_4264, label %loop_body_4264
loop_body_4264:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4264
; >ENTER_INC_PTR 3302
%dataptr_3302 = load i32, i32* %dataptr_addr
%inc_dataptr_3302 = add i32 %dataptr_3302, 10
store i32 %inc_dataptr_3302, i32* %dataptr_addr
; <ENTER_INC_PTR 3302
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4264
%dataptr_leave_4264 = load i32, i32* %dataptr_addr
%element_addr_leave_4264 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4264
%element_leave_4264 = load i8, i8* %element_addr_leave_4264
%compare_zero_leave_4264 = icmp ne i8 %element_leave_4264, 0
br i1 %compare_zero_leave_4264, label %loop_body_4264, label %post_loop_4264
post_loop_4264:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4264
; >ENTER_DEC_PTR 3313
%dataptr_3313 = load i32, i32* %dataptr_addr
%dec_dataptr_3313 = sub i32 %dataptr_3313, 10
store i32 %dec_dataptr_3313, i32* %dataptr_addr
; <ENTER_DEC_PTR 3313
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4267
%dataptr_enter_4267 = load i32, i32* %dataptr_addr
%element_addr_enter_4267 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4267
%element_enter_4267 = load i8, i8* %element_addr_enter_4267
%compare_zero_enter_4267 = icmp eq i8 %element_enter_4267, 0
br i1 %compare_zero_enter_4267, label %post_loop_4267, label %loop_body_4267
loop_body_4267:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4267
; >ENTER_DEC_PTR 3325
%dataptr_3325 = load i32, i32* %dataptr_addr
%dec_dataptr_3325 = sub i32 %dataptr_3325, 6
store i32 %dec_dataptr_3325, i32* %dataptr_addr
; <ENTER_DEC_PTR 3325
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4266
%dataptr_enter_4266 = load i32, i32* %dataptr_addr
%element_addr_enter_4266 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4266
%element_enter_4266 = load i8, i8* %element_addr_enter_4266
%compare_zero_enter_4266 = icmp eq i8 %element_enter_4266, 0
br i1 %compare_zero_enter_4266, label %post_loop_4266, label %loop_body_4266
loop_body_4266:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4266
; >ENTER_DEC_PTR 3332
%dataptr_3332 = load i32, i32* %dataptr_addr
%dec_dataptr_3332 = sub i32 %dataptr_3332, 4
store i32 %dec_dataptr_3332, i32* %dataptr_addr
; <ENTER_DEC_PTR 3332
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4265
%dataptr_enter_4265 = load i32, i32* %dataptr_addr
%element_addr_enter_4265 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4265
%element_enter_4265 = load i8, i8* %element_addr_enter_4265
%compare_zero_enter_4265 = icmp eq i8 %element_enter_4265, 0
br i1 %compare_zero_enter_4265, label %post_loop_4265, label %loop_body_4265
loop_body_4265:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4265
; >ENTER_DEC_PTR 3337
%dataptr_3337 = load i32, i32* %dataptr_addr
%dec_dataptr_3337 = sub i32 %dataptr_3337, 10
store i32 %dec_dataptr_3337, i32* %dataptr_addr
; <ENTER_DEC_PTR 3337
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4265
%dataptr_leave_4265 = load i32, i32* %dataptr_addr
%element_addr_leave_4265 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4265
%element_leave_4265 = load i8, i8* %element_addr_leave_4265
%compare_zero_leave_4265 = icmp ne i8 %element_leave_4265, 0
br i1 %compare_zero_leave_4265, label %loop_body_4265, label %post_loop_4265
post_loop_4265:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4265
; >ENTER_INC_PTR 3348
%dataptr_3348 = load i32, i32* %dataptr_addr
%inc_dataptr_3348 = add i32 %dataptr_3348, 4
store i32 %inc_dataptr_3348, i32* %dataptr_addr
; <ENTER_INC_PTR 3348
; >ENTER_INC_DATA 3352
%dataptr_3352 = load i32, i32* %dataptr_addr
%element_addr_3352 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3352
%element_3352 = load i8, i8* %element_addr_3352
%inc_element_3352 = add i8 %element_3352, 1
store i8 %inc_element_3352, i8* %element_addr_3352
; <ENTER_INC_DATA 3352
; >ENTER_DEC_PTR 3353
%dataptr_3353 = load i32, i32* %dataptr_addr
%dec_dataptr_3353 = sub i32 %dataptr_3353, 10
store i32 %dec_dataptr_3353, i32* %dataptr_addr
; <ENTER_DEC_PTR 3353
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4266
%dataptr_leave_4266 = load i32, i32* %dataptr_addr
%element_addr_leave_4266 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4266
%element_leave_4266 = load i8, i8* %element_addr_leave_4266
%compare_zero_leave_4266 = icmp ne i8 %element_leave_4266, 0
br i1 %compare_zero_leave_4266, label %loop_body_4266, label %post_loop_4266
post_loop_4266:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4266
; >ENTER_DEC_PTR 3364
%dataptr_3364 = load i32, i32* %dataptr_addr
%dec_dataptr_3364 = sub i32 %dataptr_3364, 4
store i32 %dec_dataptr_3364, i32* %dataptr_addr
; <ENTER_DEC_PTR 3364
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4267
%dataptr_leave_4267 = load i32, i32* %dataptr_addr
%element_addr_leave_4267 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4267
%element_leave_4267 = load i8, i8* %element_addr_leave_4267
%compare_zero_leave_4267 = icmp ne i8 %element_leave_4267, 0
br i1 %compare_zero_leave_4267, label %loop_body_4267, label %post_loop_4267
post_loop_4267:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4267
; >ENTER_INC_PTR 3370
%dataptr_3370 = load i32, i32* %dataptr_addr
%inc_dataptr_3370 = add i32 %dataptr_3370, 20
store i32 %inc_dataptr_3370, i32* %dataptr_addr
; <ENTER_INC_PTR 3370
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4268
%dataptr_enter_4268 = load i32, i32* %dataptr_addr
%element_addr_enter_4268 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4268
%element_enter_4268 = load i8, i8* %element_addr_enter_4268
%compare_zero_enter_4268 = icmp eq i8 %element_enter_4268, 0
br i1 %compare_zero_enter_4268, label %post_loop_4268, label %loop_body_4268
loop_body_4268:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4268
; >ENTER_INC_PTR 3391
%dataptr_3391 = load i32, i32* %dataptr_addr
%inc_dataptr_3391 = add i32 %dataptr_3391, 10
store i32 %inc_dataptr_3391, i32* %dataptr_addr
; <ENTER_INC_PTR 3391
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4268
%dataptr_leave_4268 = load i32, i32* %dataptr_addr
%element_addr_leave_4268 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4268
%element_leave_4268 = load i8, i8* %element_addr_leave_4268
%compare_zero_leave_4268 = icmp ne i8 %element_leave_4268, 0
br i1 %compare_zero_leave_4268, label %loop_body_4268, label %post_loop_4268
post_loop_4268:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4268
; >ENTER_DEC_PTR 3402
%dataptr_3402 = load i32, i32* %dataptr_addr
%dec_dataptr_3402 = sub i32 %dataptr_3402, 10
store i32 %dec_dataptr_3402, i32* %dataptr_addr
; <ENTER_DEC_PTR 3402
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4269
%dataptr_enter_4269 = load i32, i32* %dataptr_addr
%element_addr_enter_4269 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4269
%element_enter_4269 = load i8, i8* %element_addr_enter_4269
%compare_zero_enter_4269 = icmp eq i8 %element_enter_4269, 0
br i1 %compare_zero_enter_4269, label %post_loop_4269, label %loop_body_4269
loop_body_4269:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4269
; >ENTER_DEC_PTR 3413
%dataptr_3413 = load i32, i32* %dataptr_addr
%dec_dataptr_3413 = sub i32 %dataptr_3413, 10
store i32 %dec_dataptr_3413, i32* %dataptr_addr
; <ENTER_DEC_PTR 3413
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4269
%dataptr_leave_4269 = load i32, i32* %dataptr_addr
%element_addr_leave_4269 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4269
%element_leave_4269 = load i8, i8* %element_addr_leave_4269
%compare_zero_leave_4269 = icmp ne i8 %element_leave_4269, 0
br i1 %compare_zero_leave_4269, label %loop_body_4269, label %post_loop_4269
post_loop_4269:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4269
; >ENTER_INC_PTR 3425
%dataptr_3425 = load i32, i32* %dataptr_addr
%inc_dataptr_3425 = add i32 %dataptr_3425, 4
store i32 %inc_dataptr_3425, i32* %dataptr_addr
; <ENTER_INC_PTR 3425
; >ENTER_DEC_DATA 3429
%dataptr_3429 = load i32, i32* %dataptr_addr
%element_addr_3429 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3429
%element_3429 = load i8, i8* %element_addr_3429
%sub_element_3429 = sub i8 %element_3429, 1
store i8 %sub_element_3429, i8* %element_addr_3429
; <ENTER_DEC_DATA 3429
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4278
%dataptr_enter_4278 = load i32, i32* %dataptr_addr
%element_addr_enter_4278 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4278
%element_enter_4278 = load i8, i8* %element_addr_enter_4278
%compare_zero_enter_4278 = icmp eq i8 %element_enter_4278, 0
br i1 %compare_zero_enter_4278, label %post_loop_4278, label %loop_body_4278
loop_body_4278:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4278
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4270
%dataptr_enter_4270 = load i32, i32* %dataptr_addr
%element_addr_enter_4270 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4270
%element_enter_4270 = load i8, i8* %element_addr_enter_4270
%compare_zero_enter_4270 = icmp eq i8 %element_enter_4270, 0
br i1 %compare_zero_enter_4270, label %post_loop_4270, label %loop_body_4270
loop_body_4270:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4270
; >ENTER_INC_DATA 3434
%dataptr_3434 = load i32, i32* %dataptr_addr
%element_addr_3434 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3434
%element_3434 = load i8, i8* %element_addr_3434
%inc_element_3434 = add i8 %element_3434, 1
store i8 %inc_element_3434, i8* %element_addr_3434
; <ENTER_INC_DATA 3434
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4270
%dataptr_leave_4270 = load i32, i32* %dataptr_addr
%element_addr_leave_4270 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4270
%element_leave_4270 = load i8, i8* %element_addr_leave_4270
%compare_zero_leave_4270 = icmp ne i8 %element_leave_4270, 0
br i1 %compare_zero_leave_4270, label %loop_body_4270, label %post_loop_4270
post_loop_4270:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4270
; >ENTER_INC_PTR 3437
%dataptr_3437 = load i32, i32* %dataptr_addr
%inc_dataptr_3437 = add i32 %dataptr_3437, 8
store i32 %inc_dataptr_3437, i32* %dataptr_addr
; <ENTER_INC_PTR 3437
; >ENTER_DEC_DATA 3445
%dataptr_3445 = load i32, i32* %dataptr_addr
%element_addr_3445 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3445
%element_3445 = load i8, i8* %element_addr_3445
%sub_element_3445 = sub i8 %element_3445, 1
store i8 %sub_element_3445, i8* %element_addr_3445
; <ENTER_DEC_DATA 3445
; >ENTER_DEC_PTR 3446
%dataptr_3446 = load i32, i32* %dataptr_addr
%dec_dataptr_3446 = sub i32 %dataptr_3446, 2
store i32 %dec_dataptr_3446, i32* %dataptr_addr
; <ENTER_DEC_PTR 3446
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4273
%dataptr_enter_4273 = load i32, i32* %dataptr_addr
%element_addr_enter_4273 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4273
%element_enter_4273 = load i8, i8* %element_addr_enter_4273
%compare_zero_enter_4273 = icmp eq i8 %element_enter_4273, 0
br i1 %compare_zero_enter_4273, label %post_loop_4273, label %loop_body_4273
loop_body_4273:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4273
; >ENTER_INC_PTR 3449
%dataptr_3449 = load i32, i32* %dataptr_addr
%inc_dataptr_3449 = add i32 %dataptr_3449, 1
store i32 %inc_dataptr_3449, i32* %dataptr_addr
; <ENTER_INC_PTR 3449
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4271
%dataptr_enter_4271 = load i32, i32* %dataptr_addr
%element_addr_enter_4271 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4271
%element_enter_4271 = load i8, i8* %element_addr_enter_4271
%compare_zero_enter_4271 = icmp eq i8 %element_enter_4271, 0
br i1 %compare_zero_enter_4271, label %post_loop_4271, label %loop_body_4271
loop_body_4271:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4271
; >ENTER_DEC_DATA 3451
%dataptr_3451 = load i32, i32* %dataptr_addr
%element_addr_3451 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3451
%element_3451 = load i8, i8* %element_addr_3451
%sub_element_3451 = sub i8 %element_3451, 1
store i8 %sub_element_3451, i8* %element_addr_3451
; <ENTER_DEC_DATA 3451
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4271
%dataptr_leave_4271 = load i32, i32* %dataptr_addr
%element_addr_leave_4271 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4271
%element_leave_4271 = load i8, i8* %element_addr_leave_4271
%compare_zero_leave_4271 = icmp ne i8 %element_leave_4271, 0
br i1 %compare_zero_leave_4271, label %loop_body_4271, label %post_loop_4271
post_loop_4271:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4271
; >ENTER_INC_PTR 3453
%dataptr_3453 = load i32, i32* %dataptr_addr
%inc_dataptr_3453 = add i32 %dataptr_3453, 2
store i32 %inc_dataptr_3453, i32* %dataptr_addr
; <ENTER_INC_PTR 3453
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4272
%dataptr_enter_4272 = load i32, i32* %dataptr_addr
%element_addr_enter_4272 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4272
%element_enter_4272 = load i8, i8* %element_addr_enter_4272
%compare_zero_enter_4272 = icmp eq i8 %element_enter_4272, 0
br i1 %compare_zero_enter_4272, label %post_loop_4272, label %loop_body_4272
loop_body_4272:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4272
; >ENTER_DEC_DATA 3456
%dataptr_3456 = load i32, i32* %dataptr_addr
%element_addr_3456 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3456
%element_3456 = load i8, i8* %element_addr_3456
%sub_element_3456 = sub i8 %element_3456, 1
store i8 %sub_element_3456, i8* %element_addr_3456
; <ENTER_DEC_DATA 3456
; >ENTER_DEC_PTR 3457
%dataptr_3457 = load i32, i32* %dataptr_addr
%dec_dataptr_3457 = sub i32 %dataptr_3457, 2
store i32 %dec_dataptr_3457, i32* %dataptr_addr
; <ENTER_DEC_PTR 3457
; >ENTER_INC_DATA 3459
%dataptr_3459 = load i32, i32* %dataptr_addr
%element_addr_3459 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3459
%element_3459 = load i8, i8* %element_addr_3459
%inc_element_3459 = add i8 %element_3459, 1
store i8 %inc_element_3459, i8* %element_addr_3459
; <ENTER_INC_DATA 3459
; >ENTER_INC_PTR 3460
%dataptr_3460 = load i32, i32* %dataptr_addr
%inc_dataptr_3460 = add i32 %dataptr_3460, 2
store i32 %inc_dataptr_3460, i32* %dataptr_addr
; <ENTER_INC_PTR 3460
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4272
%dataptr_leave_4272 = load i32, i32* %dataptr_addr
%element_addr_leave_4272 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4272
%element_leave_4272 = load i8, i8* %element_addr_leave_4272
%compare_zero_leave_4272 = icmp ne i8 %element_leave_4272, 0
br i1 %compare_zero_leave_4272, label %loop_body_4272, label %post_loop_4272
post_loop_4272:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4272
; >ENTER_INC_PTR 3463
%dataptr_3463 = load i32, i32* %dataptr_addr
%inc_dataptr_3463 = add i32 %dataptr_3463, 7
store i32 %inc_dataptr_3463, i32* %dataptr_addr
; <ENTER_INC_PTR 3463
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4273
%dataptr_leave_4273 = load i32, i32* %dataptr_addr
%element_addr_leave_4273 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4273
%element_leave_4273 = load i8, i8* %element_addr_leave_4273
%compare_zero_leave_4273 = icmp ne i8 %element_leave_4273, 0
br i1 %compare_zero_leave_4273, label %loop_body_4273, label %post_loop_4273
post_loop_4273:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4273
; >ENTER_DEC_PTR 3471
%dataptr_3471 = load i32, i32* %dataptr_addr
%dec_dataptr_3471 = sub i32 %dataptr_3471, 10
store i32 %dec_dataptr_3471, i32* %dataptr_addr
; <ENTER_DEC_PTR 3471
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4275
%dataptr_enter_4275 = load i32, i32* %dataptr_addr
%element_addr_enter_4275 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4275
%element_enter_4275 = load i8, i8* %element_addr_enter_4275
%compare_zero_enter_4275 = icmp eq i8 %element_enter_4275, 0
br i1 %compare_zero_enter_4275, label %post_loop_4275, label %loop_body_4275
loop_body_4275:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4275
; >ENTER_INC_DATA 3483
%dataptr_3483 = load i32, i32* %dataptr_addr
%element_addr_3483 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3483
%element_3483 = load i8, i8* %element_addr_3483
%inc_element_3483 = add i8 %element_3483, 1
store i8 %inc_element_3483, i8* %element_addr_3483
; <ENTER_INC_DATA 3483
; >ENTER_INC_PTR 3484
%dataptr_3484 = load i32, i32* %dataptr_addr
%inc_dataptr_3484 = add i32 %dataptr_3484, 2
store i32 %inc_dataptr_3484, i32* %dataptr_addr
; <ENTER_INC_PTR 3484
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4274
%dataptr_enter_4274 = load i32, i32* %dataptr_addr
%element_addr_enter_4274 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4274
%element_enter_4274 = load i8, i8* %element_addr_enter_4274
%compare_zero_enter_4274 = icmp eq i8 %element_enter_4274, 0
br i1 %compare_zero_enter_4274, label %post_loop_4274, label %loop_body_4274
loop_body_4274:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4274
; >ENTER_INC_PTR 3487
%dataptr_3487 = load i32, i32* %dataptr_addr
%inc_dataptr_3487 = add i32 %dataptr_3487, 8
store i32 %inc_dataptr_3487, i32* %dataptr_addr
; <ENTER_INC_PTR 3487
; >ENTER_INC_DATA 3495
%dataptr_3495 = load i32, i32* %dataptr_addr
%element_addr_3495 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3495
%element_3495 = load i8, i8* %element_addr_3495
%inc_element_3495 = add i8 %element_3495, 1
store i8 %inc_element_3495, i8* %element_addr_3495
; <ENTER_INC_DATA 3495
; >ENTER_INC_PTR 3496
%dataptr_3496 = load i32, i32* %dataptr_addr
%inc_dataptr_3496 = add i32 %dataptr_3496, 2
store i32 %inc_dataptr_3496, i32* %dataptr_addr
; <ENTER_INC_PTR 3496
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4274
%dataptr_leave_4274 = load i32, i32* %dataptr_addr
%element_addr_leave_4274 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4274
%element_leave_4274 = load i8, i8* %element_addr_leave_4274
%compare_zero_leave_4274 = icmp ne i8 %element_leave_4274, 0
br i1 %compare_zero_leave_4274, label %loop_body_4274, label %post_loop_4274
post_loop_4274:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4274
; >ENTER_DEC_PTR 3499
%dataptr_3499 = load i32, i32* %dataptr_addr
%dec_dataptr_3499 = sub i32 %dataptr_3499, 2
store i32 %dec_dataptr_3499, i32* %dataptr_addr
; <ENTER_DEC_PTR 3499
; >ENTER_DEC_DATA 3501
%dataptr_3501 = load i32, i32* %dataptr_addr
%element_addr_3501 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3501
%element_3501 = load i8, i8* %element_addr_3501
%sub_element_3501 = sub i8 %element_3501, 1
store i8 %sub_element_3501, i8* %element_addr_3501
; <ENTER_DEC_DATA 3501
; >ENTER_DEC_PTR 3502
%dataptr_3502 = load i32, i32* %dataptr_addr
%dec_dataptr_3502 = sub i32 %dataptr_3502, 10
store i32 %dec_dataptr_3502, i32* %dataptr_addr
; <ENTER_DEC_PTR 3502
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4275
%dataptr_leave_4275 = load i32, i32* %dataptr_addr
%element_addr_leave_4275 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4275
%element_leave_4275 = load i8, i8* %element_addr_leave_4275
%compare_zero_leave_4275 = icmp ne i8 %element_leave_4275, 0
br i1 %compare_zero_leave_4275, label %loop_body_4275, label %post_loop_4275
post_loop_4275:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4275
; >ENTER_DEC_DATA 3513
%dataptr_3513 = load i32, i32* %dataptr_addr
%element_addr_3513 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3513
%element_3513 = load i8, i8* %element_addr_3513
%sub_element_3513 = sub i8 %element_3513, 1
store i8 %sub_element_3513, i8* %element_addr_3513
; <ENTER_DEC_DATA 3513
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4276
%dataptr_enter_4276 = load i32, i32* %dataptr_addr
%element_addr_enter_4276 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4276
%element_enter_4276 = load i8, i8* %element_addr_enter_4276
%compare_zero_enter_4276 = icmp eq i8 %element_enter_4276, 0
br i1 %compare_zero_enter_4276, label %post_loop_4276, label %loop_body_4276
loop_body_4276:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4276
; >ENTER_INC_PTR 3516
%dataptr_3516 = load i32, i32* %dataptr_addr
%inc_dataptr_3516 = add i32 %dataptr_3516, 2
store i32 %inc_dataptr_3516, i32* %dataptr_addr
; <ENTER_INC_PTR 3516
; >ENTER_INC_DATA 3518
%dataptr_3518 = load i32, i32* %dataptr_addr
%element_addr_3518 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3518
%element_3518 = load i8, i8* %element_addr_3518
%inc_element_3518 = add i8 %element_3518, 48
store i8 %inc_element_3518, i8* %element_addr_3518
; <ENTER_INC_DATA 3518
; >ENTER_WRITE_STDOUT 3566
ret i32 3566
post_3566:
; <ENTER_WRITE_STDOUT 3566
; >ENTER_DEC_DATA 3568
%dataptr_3568 = load i32, i32* %dataptr_addr
%element_addr_3568 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3568
%element_3568 = load i8, i8* %element_addr_3568
%sub_element_3568 = sub i8 %element_3568, 48
store i8 %sub_element_3568, i8* %element_addr_3568
; <ENTER_DEC_DATA 3568
; >ENTER_DEC_PTR 3616
%dataptr_3616 = load i32, i32* %dataptr_addr
%dec_dataptr_3616 = sub i32 %dataptr_3616, 12
store i32 %dec_dataptr_3616, i32* %dataptr_addr
; <ENTER_DEC_PTR 3616
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4276
%dataptr_leave_4276 = load i32, i32* %dataptr_addr
%element_addr_leave_4276 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4276
%element_leave_4276 = load i8, i8* %element_addr_leave_4276
%compare_zero_leave_4276 = icmp ne i8 %element_leave_4276, 0
br i1 %compare_zero_leave_4276, label %loop_body_4276, label %post_loop_4276
post_loop_4276:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4276
; >ENTER_INC_DATA 3630
%dataptr_3630 = load i32, i32* %dataptr_addr
%element_addr_3630 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3630
%element_3630 = load i8, i8* %element_addr_3630
%inc_element_3630 = add i8 %element_3630, 32
store i8 %inc_element_3630, i8* %element_addr_3630
; <ENTER_INC_DATA 3630
; >ENTER_WRITE_STDOUT 3662
ret i32 3662
post_3662:
; <ENTER_WRITE_STDOUT 3662
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4277
%dataptr_enter_4277 = load i32, i32* %dataptr_addr
%element_addr_enter_4277 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4277
%element_enter_4277 = load i8, i8* %element_addr_enter_4277
%compare_zero_enter_4277 = icmp eq i8 %element_enter_4277, 0
br i1 %compare_zero_enter_4277, label %post_loop_4277, label %loop_body_4277
loop_body_4277:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4277
; >ENTER_DEC_DATA 3664
%dataptr_3664 = load i32, i32* %dataptr_addr
%element_addr_3664 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3664
%element_3664 = load i8, i8* %element_addr_3664
%sub_element_3664 = sub i8 %element_3664, 1
store i8 %sub_element_3664, i8* %element_addr_3664
; <ENTER_DEC_DATA 3664
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4277
%dataptr_leave_4277 = load i32, i32* %dataptr_addr
%element_addr_leave_4277 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4277
%element_leave_4277 = load i8, i8* %element_addr_leave_4277
%compare_zero_leave_4277 = icmp ne i8 %element_leave_4277, 0
br i1 %compare_zero_leave_4277, label %loop_body_4277, label %post_loop_4277
post_loop_4277:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4277
; >ENTER_INC_PTR 3666
%dataptr_3666 = load i32, i32* %dataptr_addr
%inc_dataptr_3666 = add i32 %dataptr_3666, 4
store i32 %inc_dataptr_3666, i32* %dataptr_addr
; <ENTER_INC_PTR 3666
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4278
%dataptr_leave_4278 = load i32, i32* %dataptr_addr
%element_addr_leave_4278 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4278
%element_leave_4278 = load i8, i8* %element_addr_leave_4278
%compare_zero_leave_4278 = icmp ne i8 %element_leave_4278, 0
br i1 %compare_zero_leave_4278, label %loop_body_4278, label %post_loop_4278
post_loop_4278:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4278
; >ENTER_INC_PTR 3673
%dataptr_3673 = load i32, i32* %dataptr_addr
%inc_dataptr_3673 = add i32 %dataptr_3673, 6
store i32 %inc_dataptr_3673, i32* %dataptr_addr
; <ENTER_INC_PTR 3673
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4290
%dataptr_enter_4290 = load i32, i32* %dataptr_addr
%element_addr_enter_4290 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4290
%element_enter_4290 = load i8, i8* %element_addr_enter_4290
%compare_zero_enter_4290 = icmp eq i8 %element_enter_4290, 0
br i1 %compare_zero_enter_4290, label %post_loop_4290, label %loop_body_4290
loop_body_4290:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4290
; >ENTER_INC_PTR 3681
%dataptr_3681 = load i32, i32* %dataptr_addr
%inc_dataptr_3681 = add i32 %dataptr_3681, 2
store i32 %inc_dataptr_3681, i32* %dataptr_addr
; <ENTER_INC_PTR 3681
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4289
%dataptr_enter_4289 = load i32, i32* %dataptr_addr
%element_addr_enter_4289 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4289
%element_enter_4289 = load i8, i8* %element_addr_enter_4289
%compare_zero_enter_4289 = icmp eq i8 %element_enter_4289, 0
br i1 %compare_zero_enter_4289, label %post_loop_4289, label %loop_body_4289
loop_body_4289:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4289
; >ENTER_DEC_DATA 3684
%dataptr_3684 = load i32, i32* %dataptr_addr
%element_addr_3684 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3684
%element_3684 = load i8, i8* %element_addr_3684
%sub_element_3684 = sub i8 %element_3684, 1
store i8 %sub_element_3684, i8* %element_addr_3684
; <ENTER_DEC_DATA 3684
; >ENTER_INC_PTR 3685
%dataptr_3685 = load i32, i32* %dataptr_addr
%inc_dataptr_3685 = add i32 %dataptr_3685, 5
store i32 %inc_dataptr_3685, i32* %dataptr_addr
; <ENTER_INC_PTR 3685
; >ENTER_INC_DATA 3690
%dataptr_3690 = load i32, i32* %dataptr_addr
%element_addr_3690 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3690
%element_3690 = load i8, i8* %element_addr_3690
%inc_element_3690 = add i8 %element_3690, 1
store i8 %inc_element_3690, i8* %element_addr_3690
; <ENTER_INC_DATA 3690
; >ENTER_DEC_PTR 3691
%dataptr_3691 = load i32, i32* %dataptr_addr
%dec_dataptr_3691 = sub i32 %dataptr_3691, 5
store i32 %dec_dataptr_3691, i32* %dataptr_addr
; <ENTER_DEC_PTR 3691
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4288
%dataptr_enter_4288 = load i32, i32* %dataptr_addr
%element_addr_enter_4288 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4288
%element_enter_4288 = load i8, i8* %element_addr_enter_4288
%compare_zero_enter_4288 = icmp eq i8 %element_enter_4288, 0
br i1 %compare_zero_enter_4288, label %post_loop_4288, label %loop_body_4288
loop_body_4288:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4288
; >ENTER_DEC_DATA 3697
%dataptr_3697 = load i32, i32* %dataptr_addr
%element_addr_3697 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3697
%element_3697 = load i8, i8* %element_addr_3697
%sub_element_3697 = sub i8 %element_3697, 1
store i8 %sub_element_3697, i8* %element_addr_3697
; <ENTER_DEC_DATA 3697
; >ENTER_INC_PTR 3698
%dataptr_3698 = load i32, i32* %dataptr_addr
%inc_dataptr_3698 = add i32 %dataptr_3698, 5
store i32 %inc_dataptr_3698, i32* %dataptr_addr
; <ENTER_INC_PTR 3698
; >ENTER_INC_DATA 3703
%dataptr_3703 = load i32, i32* %dataptr_addr
%element_addr_3703 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3703
%element_3703 = load i8, i8* %element_addr_3703
%inc_element_3703 = add i8 %element_3703, 1
store i8 %inc_element_3703, i8* %element_addr_3703
; <ENTER_INC_DATA 3703
; >ENTER_DEC_PTR 3704
%dataptr_3704 = load i32, i32* %dataptr_addr
%dec_dataptr_3704 = sub i32 %dataptr_3704, 5
store i32 %dec_dataptr_3704, i32* %dataptr_addr
; <ENTER_DEC_PTR 3704
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4287
%dataptr_enter_4287 = load i32, i32* %dataptr_addr
%element_addr_enter_4287 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4287
%element_enter_4287 = load i8, i8* %element_addr_enter_4287
%compare_zero_enter_4287 = icmp eq i8 %element_enter_4287, 0
br i1 %compare_zero_enter_4287, label %post_loop_4287, label %loop_body_4287
loop_body_4287:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4287
; >ENTER_DEC_DATA 3711
%dataptr_3711 = load i32, i32* %dataptr_addr
%element_addr_3711 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3711
%element_3711 = load i8, i8* %element_addr_3711
%sub_element_3711 = sub i8 %element_3711, 1
store i8 %sub_element_3711, i8* %element_addr_3711
; <ENTER_DEC_DATA 3711
; >ENTER_INC_PTR 3712
%dataptr_3712 = load i32, i32* %dataptr_addr
%inc_dataptr_3712 = add i32 %dataptr_3712, 5
store i32 %inc_dataptr_3712, i32* %dataptr_addr
; <ENTER_INC_PTR 3712
; >ENTER_INC_DATA 3717
%dataptr_3717 = load i32, i32* %dataptr_addr
%element_addr_3717 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3717
%element_3717 = load i8, i8* %element_addr_3717
%inc_element_3717 = add i8 %element_3717, 1
store i8 %inc_element_3717, i8* %element_addr_3717
; <ENTER_INC_DATA 3717
; >ENTER_DEC_PTR 3718
%dataptr_3718 = load i32, i32* %dataptr_addr
%dec_dataptr_3718 = sub i32 %dataptr_3718, 5
store i32 %dec_dataptr_3718, i32* %dataptr_addr
; <ENTER_DEC_PTR 3718
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4286
%dataptr_enter_4286 = load i32, i32* %dataptr_addr
%element_addr_enter_4286 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4286
%element_enter_4286 = load i8, i8* %element_addr_enter_4286
%compare_zero_enter_4286 = icmp eq i8 %element_enter_4286, 0
br i1 %compare_zero_enter_4286, label %post_loop_4286, label %loop_body_4286
loop_body_4286:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4286
; >ENTER_DEC_DATA 3724
%dataptr_3724 = load i32, i32* %dataptr_addr
%element_addr_3724 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3724
%element_3724 = load i8, i8* %element_addr_3724
%sub_element_3724 = sub i8 %element_3724, 1
store i8 %sub_element_3724, i8* %element_addr_3724
; <ENTER_DEC_DATA 3724
; >ENTER_INC_PTR 3725
%dataptr_3725 = load i32, i32* %dataptr_addr
%inc_dataptr_3725 = add i32 %dataptr_3725, 5
store i32 %inc_dataptr_3725, i32* %dataptr_addr
; <ENTER_INC_PTR 3725
; >ENTER_INC_DATA 3730
%dataptr_3730 = load i32, i32* %dataptr_addr
%element_addr_3730 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3730
%element_3730 = load i8, i8* %element_addr_3730
%inc_element_3730 = add i8 %element_3730, 1
store i8 %inc_element_3730, i8* %element_addr_3730
; <ENTER_INC_DATA 3730
; >ENTER_DEC_PTR 3731
%dataptr_3731 = load i32, i32* %dataptr_addr
%dec_dataptr_3731 = sub i32 %dataptr_3731, 5
store i32 %dec_dataptr_3731, i32* %dataptr_addr
; <ENTER_DEC_PTR 3731
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4285
%dataptr_enter_4285 = load i32, i32* %dataptr_addr
%element_addr_enter_4285 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4285
%element_enter_4285 = load i8, i8* %element_addr_enter_4285
%compare_zero_enter_4285 = icmp eq i8 %element_enter_4285, 0
br i1 %compare_zero_enter_4285, label %post_loop_4285, label %loop_body_4285
loop_body_4285:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4285
; >ENTER_DEC_DATA 3738
%dataptr_3738 = load i32, i32* %dataptr_addr
%element_addr_3738 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3738
%element_3738 = load i8, i8* %element_addr_3738
%sub_element_3738 = sub i8 %element_3738, 1
store i8 %sub_element_3738, i8* %element_addr_3738
; <ENTER_DEC_DATA 3738
; >ENTER_INC_PTR 3739
%dataptr_3739 = load i32, i32* %dataptr_addr
%inc_dataptr_3739 = add i32 %dataptr_3739, 5
store i32 %inc_dataptr_3739, i32* %dataptr_addr
; <ENTER_INC_PTR 3739
; >ENTER_INC_DATA 3744
%dataptr_3744 = load i32, i32* %dataptr_addr
%element_addr_3744 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3744
%element_3744 = load i8, i8* %element_addr_3744
%inc_element_3744 = add i8 %element_3744, 1
store i8 %inc_element_3744, i8* %element_addr_3744
; <ENTER_INC_DATA 3744
; >ENTER_DEC_PTR 3745
%dataptr_3745 = load i32, i32* %dataptr_addr
%dec_dataptr_3745 = sub i32 %dataptr_3745, 5
store i32 %dec_dataptr_3745, i32* %dataptr_addr
; <ENTER_DEC_PTR 3745
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4284
%dataptr_enter_4284 = load i32, i32* %dataptr_addr
%element_addr_enter_4284 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4284
%element_enter_4284 = load i8, i8* %element_addr_enter_4284
%compare_zero_enter_4284 = icmp eq i8 %element_enter_4284, 0
br i1 %compare_zero_enter_4284, label %post_loop_4284, label %loop_body_4284
loop_body_4284:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4284
; >ENTER_DEC_DATA 3751
%dataptr_3751 = load i32, i32* %dataptr_addr
%element_addr_3751 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3751
%element_3751 = load i8, i8* %element_addr_3751
%sub_element_3751 = sub i8 %element_3751, 1
store i8 %sub_element_3751, i8* %element_addr_3751
; <ENTER_DEC_DATA 3751
; >ENTER_INC_PTR 3752
%dataptr_3752 = load i32, i32* %dataptr_addr
%inc_dataptr_3752 = add i32 %dataptr_3752, 5
store i32 %inc_dataptr_3752, i32* %dataptr_addr
; <ENTER_INC_PTR 3752
; >ENTER_INC_DATA 3757
%dataptr_3757 = load i32, i32* %dataptr_addr
%element_addr_3757 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3757
%element_3757 = load i8, i8* %element_addr_3757
%inc_element_3757 = add i8 %element_3757, 1
store i8 %inc_element_3757, i8* %element_addr_3757
; <ENTER_INC_DATA 3757
; >ENTER_DEC_PTR 3758
%dataptr_3758 = load i32, i32* %dataptr_addr
%dec_dataptr_3758 = sub i32 %dataptr_3758, 5
store i32 %dec_dataptr_3758, i32* %dataptr_addr
; <ENTER_DEC_PTR 3758
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4283
%dataptr_enter_4283 = load i32, i32* %dataptr_addr
%element_addr_enter_4283 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4283
%element_enter_4283 = load i8, i8* %element_addr_enter_4283
%compare_zero_enter_4283 = icmp eq i8 %element_enter_4283, 0
br i1 %compare_zero_enter_4283, label %post_loop_4283, label %loop_body_4283
loop_body_4283:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4283
; >ENTER_DEC_DATA 3765
%dataptr_3765 = load i32, i32* %dataptr_addr
%element_addr_3765 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3765
%element_3765 = load i8, i8* %element_addr_3765
%sub_element_3765 = sub i8 %element_3765, 1
store i8 %sub_element_3765, i8* %element_addr_3765
; <ENTER_DEC_DATA 3765
; >ENTER_INC_PTR 3766
%dataptr_3766 = load i32, i32* %dataptr_addr
%inc_dataptr_3766 = add i32 %dataptr_3766, 5
store i32 %inc_dataptr_3766, i32* %dataptr_addr
; <ENTER_INC_PTR 3766
; >ENTER_INC_DATA 3771
%dataptr_3771 = load i32, i32* %dataptr_addr
%element_addr_3771 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3771
%element_3771 = load i8, i8* %element_addr_3771
%inc_element_3771 = add i8 %element_3771, 1
store i8 %inc_element_3771, i8* %element_addr_3771
; <ENTER_INC_DATA 3771
; >ENTER_DEC_PTR 3772
%dataptr_3772 = load i32, i32* %dataptr_addr
%dec_dataptr_3772 = sub i32 %dataptr_3772, 5
store i32 %dec_dataptr_3772, i32* %dataptr_addr
; <ENTER_DEC_PTR 3772
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4282
%dataptr_enter_4282 = load i32, i32* %dataptr_addr
%element_addr_enter_4282 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4282
%element_enter_4282 = load i8, i8* %element_addr_enter_4282
%compare_zero_enter_4282 = icmp eq i8 %element_enter_4282, 0
br i1 %compare_zero_enter_4282, label %post_loop_4282, label %loop_body_4282
loop_body_4282:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4282
; >ENTER_DEC_DATA 3778
%dataptr_3778 = load i32, i32* %dataptr_addr
%element_addr_3778 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3778
%element_3778 = load i8, i8* %element_addr_3778
%sub_element_3778 = sub i8 %element_3778, 1
store i8 %sub_element_3778, i8* %element_addr_3778
; <ENTER_DEC_DATA 3778
; >ENTER_INC_PTR 3779
%dataptr_3779 = load i32, i32* %dataptr_addr
%inc_dataptr_3779 = add i32 %dataptr_3779, 5
store i32 %inc_dataptr_3779, i32* %dataptr_addr
; <ENTER_INC_PTR 3779
; >ENTER_INC_DATA 3784
%dataptr_3784 = load i32, i32* %dataptr_addr
%element_addr_3784 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3784
%element_3784 = load i8, i8* %element_addr_3784
%inc_element_3784 = add i8 %element_3784, 1
store i8 %inc_element_3784, i8* %element_addr_3784
; <ENTER_INC_DATA 3784
; >ENTER_DEC_PTR 3785
%dataptr_3785 = load i32, i32* %dataptr_addr
%dec_dataptr_3785 = sub i32 %dataptr_3785, 5
store i32 %dec_dataptr_3785, i32* %dataptr_addr
; <ENTER_DEC_PTR 3785
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4281
%dataptr_enter_4281 = load i32, i32* %dataptr_addr
%element_addr_enter_4281 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4281
%element_enter_4281 = load i8, i8* %element_addr_enter_4281
%compare_zero_enter_4281 = icmp eq i8 %element_enter_4281, 0
br i1 %compare_zero_enter_4281, label %post_loop_4281, label %loop_body_4281
loop_body_4281:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4281
; >ENTER_DEC_DATA 3792
%dataptr_3792 = load i32, i32* %dataptr_addr
%element_addr_3792 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3792
%element_3792 = load i8, i8* %element_addr_3792
%sub_element_3792 = sub i8 %element_3792, 1
store i8 %sub_element_3792, i8* %element_addr_3792
; <ENTER_DEC_DATA 3792
; >ENTER_INC_PTR 3793
%dataptr_3793 = load i32, i32* %dataptr_addr
%inc_dataptr_3793 = add i32 %dataptr_3793, 5
store i32 %inc_dataptr_3793, i32* %dataptr_addr
; <ENTER_INC_PTR 3793
; >ENTER_INC_DATA 3798
%dataptr_3798 = load i32, i32* %dataptr_addr
%element_addr_3798 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3798
%element_3798 = load i8, i8* %element_addr_3798
%inc_element_3798 = add i8 %element_3798, 1
store i8 %inc_element_3798, i8* %element_addr_3798
; <ENTER_INC_DATA 3798
; >ENTER_DEC_PTR 3799
%dataptr_3799 = load i32, i32* %dataptr_addr
%dec_dataptr_3799 = sub i32 %dataptr_3799, 5
store i32 %dec_dataptr_3799, i32* %dataptr_addr
; <ENTER_DEC_PTR 3799
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4280
%dataptr_enter_4280 = load i32, i32* %dataptr_addr
%element_addr_enter_4280 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4280
%element_enter_4280 = load i8, i8* %element_addr_enter_4280
%compare_zero_enter_4280 = icmp eq i8 %element_enter_4280, 0
br i1 %compare_zero_enter_4280, label %post_loop_4280, label %loop_body_4280
loop_body_4280:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4280
; >ENTER_DEC_DATA 3805
%dataptr_3805 = load i32, i32* %dataptr_addr
%element_addr_3805 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3805
%element_3805 = load i8, i8* %element_addr_3805
%sub_element_3805 = sub i8 %element_3805, 1
store i8 %sub_element_3805, i8* %element_addr_3805
; <ENTER_DEC_DATA 3805
; >ENTER_INC_PTR 3806
%dataptr_3806 = load i32, i32* %dataptr_addr
%inc_dataptr_3806 = add i32 %dataptr_3806, 5
store i32 %inc_dataptr_3806, i32* %dataptr_addr
; <ENTER_INC_PTR 3806
; >ENTER_DEC_DATA 3811
%dataptr_3811 = load i32, i32* %dataptr_addr
%element_addr_3811 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3811
%element_3811 = load i8, i8* %element_addr_3811
%sub_element_3811 = sub i8 %element_3811, 9
store i8 %sub_element_3811, i8* %element_addr_3811
; <ENTER_DEC_DATA 3811
; >ENTER_INC_PTR 3820
%dataptr_3820 = load i32, i32* %dataptr_addr
%inc_dataptr_3820 = add i32 %dataptr_3820, 5
store i32 %inc_dataptr_3820, i32* %dataptr_addr
; <ENTER_INC_PTR 3820
; >ENTER_INC_DATA 3825
%dataptr_3825 = load i32, i32* %dataptr_addr
%element_addr_3825 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3825
%element_3825 = load i8, i8* %element_addr_3825
%inc_element_3825 = add i8 %element_3825, 1
store i8 %inc_element_3825, i8* %element_addr_3825
; <ENTER_INC_DATA 3825
; >ENTER_DEC_PTR 3826
%dataptr_3826 = load i32, i32* %dataptr_addr
%dec_dataptr_3826 = sub i32 %dataptr_3826, 10
store i32 %dec_dataptr_3826, i32* %dataptr_addr
; <ENTER_DEC_PTR 3826
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4279
%dataptr_enter_4279 = load i32, i32* %dataptr_addr
%element_addr_enter_4279 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4279
%element_enter_4279 = load i8, i8* %element_addr_enter_4279
%compare_zero_enter_4279 = icmp eq i8 %element_enter_4279, 0
br i1 %compare_zero_enter_4279, label %post_loop_4279, label %loop_body_4279
loop_body_4279:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4279
; >ENTER_DEC_DATA 3838
%dataptr_3838 = load i32, i32* %dataptr_addr
%element_addr_3838 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3838
%element_3838 = load i8, i8* %element_addr_3838
%sub_element_3838 = sub i8 %element_3838, 1
store i8 %sub_element_3838, i8* %element_addr_3838
; <ENTER_DEC_DATA 3838
; >ENTER_INC_PTR 3839
%dataptr_3839 = load i32, i32* %dataptr_addr
%inc_dataptr_3839 = add i32 %dataptr_3839, 5
store i32 %inc_dataptr_3839, i32* %dataptr_addr
; <ENTER_INC_PTR 3839
; >ENTER_INC_DATA 3844
%dataptr_3844 = load i32, i32* %dataptr_addr
%element_addr_3844 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3844
%element_3844 = load i8, i8* %element_addr_3844
%inc_element_3844 = add i8 %element_3844, 1
store i8 %inc_element_3844, i8* %element_addr_3844
; <ENTER_INC_DATA 3844
; >ENTER_DEC_PTR 3845
%dataptr_3845 = load i32, i32* %dataptr_addr
%dec_dataptr_3845 = sub i32 %dataptr_3845, 5
store i32 %dec_dataptr_3845, i32* %dataptr_addr
; <ENTER_DEC_PTR 3845
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4279
%dataptr_leave_4279 = load i32, i32* %dataptr_addr
%element_addr_leave_4279 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4279
%element_leave_4279 = load i8, i8* %element_addr_leave_4279
%compare_zero_leave_4279 = icmp ne i8 %element_leave_4279, 0
br i1 %compare_zero_leave_4279, label %loop_body_4279, label %post_loop_4279
post_loop_4279:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4279
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4280
%dataptr_leave_4280 = load i32, i32* %dataptr_addr
%element_addr_leave_4280 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4280
%element_leave_4280 = load i8, i8* %element_addr_leave_4280
%compare_zero_leave_4280 = icmp ne i8 %element_leave_4280, 0
br i1 %compare_zero_leave_4280, label %loop_body_4280, label %post_loop_4280
post_loop_4280:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4280
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4281
%dataptr_leave_4281 = load i32, i32* %dataptr_addr
%element_addr_leave_4281 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4281
%element_leave_4281 = load i8, i8* %element_addr_leave_4281
%compare_zero_leave_4281 = icmp ne i8 %element_leave_4281, 0
br i1 %compare_zero_leave_4281, label %loop_body_4281, label %post_loop_4281
post_loop_4281:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4281
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4282
%dataptr_leave_4282 = load i32, i32* %dataptr_addr
%element_addr_leave_4282 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4282
%element_leave_4282 = load i8, i8* %element_addr_leave_4282
%compare_zero_leave_4282 = icmp ne i8 %element_leave_4282, 0
br i1 %compare_zero_leave_4282, label %loop_body_4282, label %post_loop_4282
post_loop_4282:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4282
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4283
%dataptr_leave_4283 = load i32, i32* %dataptr_addr
%element_addr_leave_4283 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4283
%element_leave_4283 = load i8, i8* %element_addr_leave_4283
%compare_zero_leave_4283 = icmp ne i8 %element_leave_4283, 0
br i1 %compare_zero_leave_4283, label %loop_body_4283, label %post_loop_4283
post_loop_4283:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4283
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4284
%dataptr_leave_4284 = load i32, i32* %dataptr_addr
%element_addr_leave_4284 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4284
%element_leave_4284 = load i8, i8* %element_addr_leave_4284
%compare_zero_leave_4284 = icmp ne i8 %element_leave_4284, 0
br i1 %compare_zero_leave_4284, label %loop_body_4284, label %post_loop_4284
post_loop_4284:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4284
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4285
%dataptr_leave_4285 = load i32, i32* %dataptr_addr
%element_addr_leave_4285 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4285
%element_leave_4285 = load i8, i8* %element_addr_leave_4285
%compare_zero_leave_4285 = icmp ne i8 %element_leave_4285, 0
br i1 %compare_zero_leave_4285, label %loop_body_4285, label %post_loop_4285
post_loop_4285:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4285
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4286
%dataptr_leave_4286 = load i32, i32* %dataptr_addr
%element_addr_leave_4286 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4286
%element_leave_4286 = load i8, i8* %element_addr_leave_4286
%compare_zero_leave_4286 = icmp ne i8 %element_leave_4286, 0
br i1 %compare_zero_leave_4286, label %loop_body_4286, label %post_loop_4286
post_loop_4286:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4286
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4287
%dataptr_leave_4287 = load i32, i32* %dataptr_addr
%element_addr_leave_4287 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4287
%element_leave_4287 = load i8, i8* %element_addr_leave_4287
%compare_zero_leave_4287 = icmp ne i8 %element_leave_4287, 0
br i1 %compare_zero_leave_4287, label %loop_body_4287, label %post_loop_4287
post_loop_4287:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4287
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4288
%dataptr_leave_4288 = load i32, i32* %dataptr_addr
%element_addr_leave_4288 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4288
%element_leave_4288 = load i8, i8* %element_addr_leave_4288
%compare_zero_leave_4288 = icmp ne i8 %element_leave_4288, 0
br i1 %compare_zero_leave_4288, label %loop_body_4288, label %post_loop_4288
post_loop_4288:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4288
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4289
%dataptr_leave_4289 = load i32, i32* %dataptr_addr
%element_addr_leave_4289 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4289
%element_leave_4289 = load i8, i8* %element_addr_leave_4289
%compare_zero_leave_4289 = icmp ne i8 %element_leave_4289, 0
br i1 %compare_zero_leave_4289, label %loop_body_4289, label %post_loop_4289
post_loop_4289:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4289
; >ENTER_INC_PTR 3861
%dataptr_3861 = load i32, i32* %dataptr_addr
%inc_dataptr_3861 = add i32 %dataptr_3861, 8
store i32 %inc_dataptr_3861, i32* %dataptr_addr
; <ENTER_INC_PTR 3861
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4290
%dataptr_leave_4290 = load i32, i32* %dataptr_addr
%element_addr_leave_4290 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4290
%element_leave_4290 = load i8, i8* %element_addr_leave_4290
%compare_zero_leave_4290 = icmp ne i8 %element_leave_4290, 0
br i1 %compare_zero_leave_4290, label %loop_body_4290, label %post_loop_4290
post_loop_4290:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4290
; >ENTER_DEC_PTR 3871
%dataptr_3871 = load i32, i32* %dataptr_addr
%dec_dataptr_3871 = sub i32 %dataptr_3871, 10
store i32 %dec_dataptr_3871, i32* %dataptr_addr
; <ENTER_DEC_PTR 3871
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4292
%dataptr_enter_4292 = load i32, i32* %dataptr_addr
%element_addr_enter_4292 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4292
%element_enter_4292 = load i8, i8* %element_addr_enter_4292
%compare_zero_enter_4292 = icmp eq i8 %element_enter_4292, 0
br i1 %compare_zero_enter_4292, label %post_loop_4292, label %loop_body_4292
loop_body_4292:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4292
; >ENTER_INC_PTR 3882
%dataptr_3882 = load i32, i32* %dataptr_addr
%inc_dataptr_3882 = add i32 %dataptr_3882, 7
store i32 %inc_dataptr_3882, i32* %dataptr_addr
; <ENTER_INC_PTR 3882
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4291
%dataptr_enter_4291 = load i32, i32* %dataptr_addr
%element_addr_enter_4291 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4291
%element_enter_4291 = load i8, i8* %element_addr_enter_4291
%compare_zero_enter_4291 = icmp eq i8 %element_enter_4291, 0
br i1 %compare_zero_enter_4291, label %post_loop_4291, label %loop_body_4291
loop_body_4291:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4291
; >ENTER_DEC_DATA 3890
%dataptr_3890 = load i32, i32* %dataptr_addr
%element_addr_3890 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3890
%element_3890 = load i8, i8* %element_addr_3890
%sub_element_3890 = sub i8 %element_3890, 1
store i8 %sub_element_3890, i8* %element_addr_3890
; <ENTER_DEC_DATA 3890
; >ENTER_DEC_PTR 3891
%dataptr_3891 = load i32, i32* %dataptr_addr
%dec_dataptr_3891 = sub i32 %dataptr_3891, 5
store i32 %dec_dataptr_3891, i32* %dataptr_addr
; <ENTER_DEC_PTR 3891
; >ENTER_INC_DATA 3896
%dataptr_3896 = load i32, i32* %dataptr_addr
%element_addr_3896 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3896
%element_3896 = load i8, i8* %element_addr_3896
%inc_element_3896 = add i8 %element_3896, 1
store i8 %inc_element_3896, i8* %element_addr_3896
; <ENTER_INC_DATA 3896
; >ENTER_INC_PTR 3897
%dataptr_3897 = load i32, i32* %dataptr_addr
%inc_dataptr_3897 = add i32 %dataptr_3897, 5
store i32 %inc_dataptr_3897, i32* %dataptr_addr
; <ENTER_INC_PTR 3897
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4291
%dataptr_leave_4291 = load i32, i32* %dataptr_addr
%element_addr_leave_4291 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4291
%element_leave_4291 = load i8, i8* %element_addr_leave_4291
%compare_zero_leave_4291 = icmp ne i8 %element_leave_4291, 0
br i1 %compare_zero_leave_4291, label %loop_body_4291, label %post_loop_4291
post_loop_4291:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4291
; >ENTER_DEC_PTR 3903
%dataptr_3903 = load i32, i32* %dataptr_addr
%dec_dataptr_3903 = sub i32 %dataptr_3903, 17
store i32 %dec_dataptr_3903, i32* %dataptr_addr
; <ENTER_DEC_PTR 3903
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4292
%dataptr_leave_4292 = load i32, i32* %dataptr_addr
%element_addr_leave_4292 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4292
%element_leave_4292 = load i8, i8* %element_addr_leave_4292
%compare_zero_leave_4292 = icmp ne i8 %element_leave_4292, 0
br i1 %compare_zero_leave_4292, label %loop_body_4292, label %post_loop_4292
post_loop_4292:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4292
; >ENTER_INC_PTR 3922
%dataptr_3922 = load i32, i32* %dataptr_addr
%inc_dataptr_3922 = add i32 %dataptr_3922, 9
store i32 %inc_dataptr_3922, i32* %dataptr_addr
; <ENTER_INC_PTR 3922
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4293
%dataptr_leave_4293 = load i32, i32* %dataptr_addr
%element_addr_leave_4293 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4293
%element_leave_4293 = load i8, i8* %element_addr_leave_4293
%compare_zero_leave_4293 = icmp ne i8 %element_leave_4293, 0
br i1 %compare_zero_leave_4293, label %loop_body_4293, label %post_loop_4293
post_loop_4293:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4293
; >ENTER_DEC_PTR 3933
%dataptr_3933 = load i32, i32* %dataptr_addr
%dec_dataptr_3933 = sub i32 %dataptr_3933, 1
store i32 %dec_dataptr_3933, i32* %dataptr_addr
; <ENTER_DEC_PTR 3933
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4294
%dataptr_leave_4294 = load i32, i32* %dataptr_addr
%element_addr_leave_4294 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4294
%element_leave_4294 = load i8, i8* %element_addr_leave_4294
%compare_zero_leave_4294 = icmp ne i8 %element_leave_4294, 0
br i1 %compare_zero_leave_4294, label %loop_body_4294, label %post_loop_4294
post_loop_4294:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4294
; >ENTER_INC_PTR 3936
%dataptr_3936 = load i32, i32* %dataptr_addr
%inc_dataptr_3936 = add i32 %dataptr_3936, 2
store i32 %inc_dataptr_3936, i32* %dataptr_addr
; <ENTER_INC_PTR 3936
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4295
%dataptr_enter_4295 = load i32, i32* %dataptr_addr
%element_addr_enter_4295 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4295
%element_enter_4295 = load i8, i8* %element_addr_enter_4295
%compare_zero_enter_4295 = icmp eq i8 %element_enter_4295, 0
br i1 %compare_zero_enter_4295, label %post_loop_4295, label %loop_body_4295
loop_body_4295:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4295
; >ENTER_INC_PTR 3940
%dataptr_3940 = load i32, i32* %dataptr_addr
%inc_dataptr_3940 = add i32 %dataptr_3940, 10
store i32 %inc_dataptr_3940, i32* %dataptr_addr
; <ENTER_INC_PTR 3940
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4295
%dataptr_leave_4295 = load i32, i32* %dataptr_addr
%element_addr_leave_4295 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4295
%element_leave_4295 = load i8, i8* %element_addr_leave_4295
%compare_zero_leave_4295 = icmp ne i8 %element_leave_4295, 0
br i1 %compare_zero_leave_4295, label %loop_body_4295, label %post_loop_4295
post_loop_4295:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4295
; >ENTER_DEC_PTR 3951
%dataptr_3951 = load i32, i32* %dataptr_addr
%dec_dataptr_3951 = sub i32 %dataptr_3951, 10
store i32 %dec_dataptr_3951, i32* %dataptr_addr
; <ENTER_DEC_PTR 3951
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4297
%dataptr_enter_4297 = load i32, i32* %dataptr_addr
%element_addr_enter_4297 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4297
%element_enter_4297 = load i8, i8* %element_addr_enter_4297
%compare_zero_enter_4297 = icmp eq i8 %element_enter_4297, 0
br i1 %compare_zero_enter_4297, label %post_loop_4297, label %loop_body_4297
loop_body_4297:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4297
; >ENTER_INC_DATA 3962
%dataptr_3962 = load i32, i32* %dataptr_addr
%element_addr_3962 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3962
%element_3962 = load i8, i8* %element_addr_3962
%inc_element_3962 = add i8 %element_3962, 1
store i8 %inc_element_3962, i8* %element_addr_3962
; <ENTER_INC_DATA 3962
; >ENTER_INC_PTR 3963
%dataptr_3963 = load i32, i32* %dataptr_addr
%inc_dataptr_3963 = add i32 %dataptr_3963, 1
store i32 %inc_dataptr_3963, i32* %dataptr_addr
; <ENTER_INC_PTR 3963
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4296
%dataptr_enter_4296 = load i32, i32* %dataptr_addr
%element_addr_enter_4296 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4296
%element_enter_4296 = load i8, i8* %element_addr_enter_4296
%compare_zero_enter_4296 = icmp eq i8 %element_enter_4296, 0
br i1 %compare_zero_enter_4296, label %post_loop_4296, label %loop_body_4296
loop_body_4296:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4296
; >ENTER_INC_PTR 3965
%dataptr_3965 = load i32, i32* %dataptr_addr
%inc_dataptr_3965 = add i32 %dataptr_3965, 9
store i32 %inc_dataptr_3965, i32* %dataptr_addr
; <ENTER_INC_PTR 3965
; >ENTER_INC_DATA 3974
%dataptr_3974 = load i32, i32* %dataptr_addr
%element_addr_3974 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3974
%element_3974 = load i8, i8* %element_addr_3974
%inc_element_3974 = add i8 %element_3974, 1
store i8 %inc_element_3974, i8* %element_addr_3974
; <ENTER_INC_DATA 3974
; >ENTER_INC_PTR 3975
%dataptr_3975 = load i32, i32* %dataptr_addr
%inc_dataptr_3975 = add i32 %dataptr_3975, 1
store i32 %inc_dataptr_3975, i32* %dataptr_addr
; <ENTER_INC_PTR 3975
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4296
%dataptr_leave_4296 = load i32, i32* %dataptr_addr
%element_addr_leave_4296 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4296
%element_leave_4296 = load i8, i8* %element_addr_leave_4296
%compare_zero_leave_4296 = icmp ne i8 %element_leave_4296, 0
br i1 %compare_zero_leave_4296, label %loop_body_4296, label %post_loop_4296
post_loop_4296:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4296
; >ENTER_DEC_PTR 3977
%dataptr_3977 = load i32, i32* %dataptr_addr
%dec_dataptr_3977 = sub i32 %dataptr_3977, 1
store i32 %dec_dataptr_3977, i32* %dataptr_addr
; <ENTER_DEC_PTR 3977
; >ENTER_DEC_DATA 3978
%dataptr_3978 = load i32, i32* %dataptr_addr
%element_addr_3978 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3978
%element_3978 = load i8, i8* %element_addr_3978
%sub_element_3978 = sub i8 %element_3978, 1
store i8 %sub_element_3978, i8* %element_addr_3978
; <ENTER_DEC_DATA 3978
; >ENTER_DEC_PTR 3979
%dataptr_3979 = load i32, i32* %dataptr_addr
%dec_dataptr_3979 = sub i32 %dataptr_3979, 10
store i32 %dec_dataptr_3979, i32* %dataptr_addr
; <ENTER_DEC_PTR 3979
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4297
%dataptr_leave_4297 = load i32, i32* %dataptr_addr
%element_addr_leave_4297 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4297
%element_leave_4297 = load i8, i8* %element_addr_leave_4297
%compare_zero_leave_4297 = icmp ne i8 %element_leave_4297, 0
br i1 %compare_zero_leave_4297, label %loop_body_4297, label %post_loop_4297
post_loop_4297:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4297
; >ENTER_DEC_DATA 3990
%dataptr_3990 = load i32, i32* %dataptr_addr
%element_addr_3990 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3990
%element_3990 = load i8, i8* %element_addr_3990
%sub_element_3990 = sub i8 %element_3990, 1
store i8 %sub_element_3990, i8* %element_addr_3990
; <ENTER_DEC_DATA 3990
; >ENTER_LOOP_IF_DATA_NOT_ZERO 4298
%dataptr_enter_4298 = load i32, i32* %dataptr_addr
%element_addr_enter_4298 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_enter_4298
%element_enter_4298 = load i8, i8* %element_addr_enter_4298
%compare_zero_enter_4298 = icmp eq i8 %element_enter_4298, 0
br i1 %compare_zero_enter_4298, label %post_loop_4298, label %loop_body_4298
loop_body_4298:
; <ENTER_LOOP_IF_DATA_NOT_ZERO 4298
; >ENTER_INC_PTR 3993
%dataptr_3993 = load i32, i32* %dataptr_addr
%inc_dataptr_3993 = add i32 %dataptr_3993, 1
store i32 %inc_dataptr_3993, i32* %dataptr_addr
; <ENTER_INC_PTR 3993
; >ENTER_INC_DATA 3994
%dataptr_3994 = load i32, i32* %dataptr_addr
%element_addr_3994 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_3994
%element_3994 = load i8, i8* %element_addr_3994
%inc_element_3994 = add i8 %element_3994, 48
store i8 %inc_element_3994, i8* %element_addr_3994
; <ENTER_INC_DATA 3994
; >ENTER_WRITE_STDOUT 4042
ret i32 4042
post_4042:
; <ENTER_WRITE_STDOUT 4042
; >ENTER_DEC_PTR 4043
%dataptr_4043 = load i32, i32* %dataptr_addr
%dec_dataptr_4043 = sub i32 %dataptr_4043, 11
store i32 %dec_dataptr_4043, i32* %dataptr_addr
; <ENTER_DEC_PTR 4043
; >LEAVE_LOOP_IF_DATA_NOT_ZERO 4298
%dataptr_leave_4298 = load i32, i32* %dataptr_addr
%element_addr_leave_4298 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_leave_4298
%element_leave_4298 = load i8, i8* %element_addr_leave_4298
%compare_zero_leave_4298 = icmp ne i8 %element_leave_4298, 0
br i1 %compare_zero_leave_4298, label %loop_body_4298, label %post_loop_4298
post_loop_4298:
; <LEAVE_LOOP_IF_DATA_NOT_ZERO 4298
; >ENTER_INC_DATA 4056
%dataptr_4056 = load i32, i32* %dataptr_addr
%element_addr_4056 = getelementptr inbounds i8, i8* %memory, i32 %dataptr_4056
%element_4056 = load i8, i8* %element_addr_4056
%inc_element_4056 = add i8 %element_4056, 10
store i8 %inc_element_4056, i8* %element_addr_4056
; <ENTER_INC_DATA 4056
; >ENTER_WRITE_STDOUT 4066
ret i32 4066
post_4066:
; <ENTER_WRITE_STDOUT 4066
; >LEAVE_PROGRAM 4300
ret i32 0
}
; <LEAVE_PROGRAM 4300
Time: 1.887 ms
joel=#*
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment