1# This file is part of PeachPy package and is licensed under the Simplified BSD license.
2#    See license.rst for the full text of the license.
3
4import inspect
5
6import peachpy.stream
7import peachpy.arm.function
8from peachpy.arm.instructions import QuasiInstruction, Instruction, Operand
9from peachpy.arm.isa import Extension
10
11
12class ArithmeticInstruction(Instruction):
13    def __init__(self, name, destination, source_x, source_y, origin=None):
14        allowed_instructions = ['ADD', 'ADDEQ', 'ADDNE', 'ADDCS', 'ADDHS', 'ADDCC', 'ADDLO', 'ADDMI', 'ADDPL', 'ADDVS',
15                                'ADDVC', 'ADDHI', 'ADDLS', 'ADDGE', 'ADDLT', 'ADDGT', 'ADDLE',
16                                'ADDS', 'ADDSEQ', 'ADDSNE', 'ADDSCS', 'ADDSHS', 'ADDSCC', 'ADDSLO', 'ADDSMI', 'ADDSPL',
17                                'ADDSVS', 'ADDSVC', 'ADDSHI', 'ADDSLS', 'ADDSGE', 'ADDSLT', 'ADDSGT', 'ADDSLE',
18                                'ADC', 'ADCEQ', 'ADCNE', 'ADCCS', 'ADCHS', 'ADCCC', 'ADCLO', 'ADCMI', 'ADCPL', 'ADCVS',
19                                'ADCVC', 'ADCHI', 'ADCLS', 'ADCGE', 'ADCLT', 'ADCGT', 'ADCLE',
20                                'ADCS', 'ADCSEQ', 'ADCSNE', 'ADCSCS', 'ADCSHS', 'ADCSCC', 'ADCSLO', 'ADCSMI', 'ADCSPL',
21                                'ADCSVS', 'ADCSVC', 'ADCSHI', 'ADCSLS', 'ADCSGE', 'ADCSLT', 'ADCSGT', 'ADCSLE',
22                                'SUB', 'SUBEQ', 'SUBNE', 'SUBCS', 'SUBHS', 'SUBCC', 'SUBLO', 'SUBMI', 'SUBPL', 'SUBVS',
23                                'SUBVC', 'SUBHI', 'SUBLS', 'SUBGE', 'SUBLT', 'SUBGT', 'SUBLE',
24                                'SUBS', 'SUBSEQ', 'SUBSNE', 'SUBSCS', 'SUBSHS', 'SUBSCC', 'SUBSLO', 'SUBSMI', 'SUBSPL',
25                                'SUBSVS', 'SUBSVC', 'SUBSHI', 'SUBSLS', 'SUBSGE', 'SUBSLT', 'SUBSGT', 'SUBSLE',
26                                'SBC', 'SBCEQ', 'SBCNE', 'SBCCS', 'SBCHS', 'SBCCC', 'SBCLO', 'SBCMI', 'SBCPL', 'SBCVS',
27                                'SBCVC', 'SBCHI', 'SBCLS', 'SBCGE', 'SBCLT', 'SBCGT', 'SBCLE',
28                                'SBCS', 'SBCSEQ', 'SBCSNE', 'SBCSCS', 'SBCSHS', 'SBCSCC', 'SBCSLO', 'SBCSMI', 'SBCSPL',
29                                'SBCSVS', 'SBCSVC', 'SBCSHI', 'SBCSLS', 'SBCSGE', 'SBCSLT', 'SBCSGT', 'SBCSLE',
30                                'RSB', 'RSBEQ', 'RSBNE', 'RSBCS', 'RSBHS', 'RSBCC', 'RSBLO', 'RSBMI', 'RSBPL', 'RSBVS',
31                                'RSBVC', 'RSBHI', 'RSBLS', 'RSBGE', 'RSBLT', 'RSBGT', 'RSBLE',
32                                'RSBS', 'RSBSEQ', 'RSBSNE', 'RSBSCS', 'RSBSHS', 'RSBSCC', 'RSBSLO', 'RSBSMI', 'RSBSPL',
33                                'RSBSVS', 'RSBSVC', 'RSBSHI', 'RSBSLS', 'RSBSGE', 'RSBSLT', 'RSBSGT', 'RSBSLE',
34                                'RSC', 'RSCEQ', 'RSCNE', 'RSCCS', 'RSCHS', 'RSCCC', 'RSCLO', 'RSCMI', 'RSCPL', 'RSCVS',
35                                'RSCVC', 'RSCHI', 'RSCLS', 'RSCGE', 'RSCLT', 'RSCGT', 'RSCLE',
36                                'RSCS', 'RSCSEQ', 'RSCSNE', 'RSCSCS', 'RSCSHS', 'RSCSCC', 'RSCSLO', 'RSCSMI', 'RSCSPL',
37                                'RSCSVS', 'RSCSVC', 'RSCSHI', 'RSCSLS', 'RSCSGE', 'RSCSLT', 'RSCSGT', 'RSCSLE',
38                                'AND', 'ANDEQ', 'ANDNE', 'ANDCS', 'ANDHS', 'ANDCC', 'ANDLO', 'ANDMI', 'ANDPL', 'ANDVS',
39                                'ANDVC', 'ANDHI', 'ANDLS', 'ANDGE', 'ANDLT', 'ANDGT', 'ANDLE',
40                                'ANDS', 'ANDSEQ', 'ANDSNE', 'ANDSCS', 'ANDSHS', 'ANDSCC', 'ANDSLO', 'ANDSMI', 'ANDSPL',
41                                'ANDSVS', 'ANDSVC', 'ANDSHI', 'ANDSLS', 'ANDSGE', 'ANDSLT', 'ANDSGT', 'ANDSLE',
42                                'BIC', 'BICEQ', 'BICNE', 'BICCS', 'BICHS', 'BICCC', 'BICLO', 'BICMI', 'BICPL', 'BICVS',
43                                'BICVC', 'BICHI', 'BICLS', 'BICGE', 'BICLT', 'BICGT', 'BICLE',
44                                'BICS', 'BICSEQ', 'BICSNE', 'BICSCS', 'BICSHS', 'BICSCC', 'BICSLO', 'BICSMI', 'BICSPL',
45                                'BICSVS', 'BICSVC', 'BICSHI', 'BICSLS', 'BICSGE', 'BICSLT', 'BICSGT', 'BICSLE',
46                                'ORR', 'ORREQ', 'ORRNE', 'ORRCS', 'ORRHS', 'ORRCC', 'ORRLO', 'ORRMI', 'ORRPL', 'ORRVS',
47                                'ORRVC', 'ORRHI', 'ORRLS', 'ORRGE', 'ORRLT', 'ORRGT', 'ORRLE',
48                                'ORRS', 'ORRSEQ', 'ORRSNE', 'ORRSCS', 'ORRSHS', 'ORRSCC', 'ORRSLO', 'ORRSMI', 'ORRSPL',
49                                'ORRSVS', 'ORRSVC', 'ORRSHI', 'ORRSLS', 'ORRSGE', 'ORRSLT', 'ORRSGT', 'ORRSLE',
50                                'EOR', 'EOREQ', 'EORNE', 'EORCS', 'EORHS', 'EORCC', 'EORLO', 'EORMI', 'EORPL', 'EORVS',
51                                'EORVC', 'EORHI', 'EORLS', 'EORGE', 'EORLT', 'EORGT', 'EORLE',
52                                'EORS', 'EORSEQ', 'EORSNE', 'EORSCS', 'EORSHS', 'EORSCC', 'EORSLO', 'EORSMI', 'EORSPL',
53                                'EORSVS', 'EORSVC', 'EORSHI', 'EORSLS', 'EORSGE', 'EORSLT', 'EORSGT', 'EORSLE']
54        super(ArithmeticInstruction, self).__init__(name, [destination, source_x, source_y], origin=origin)
55        if name not in allowed_instructions:
56            raise ValueError('Instruction {0} is not one of the allowed instructions ({1})'
57                             .format(name, ", ".join(allowed_instructions)))
58        if destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_modified_immediate12():
59            pass
60        elif destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_shifted_general_purpose_register():
61            pass
62        else:
63            raise ValueError('Invalid operands in instruction {0} {1}, {2}, {3}'
64                             .format(name, destination, source_x, source_y))
65
66    def is_conditional(self):
67        return self.name[-2:] in {"EQ", "NE", "CS", "CC", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT",
68                                  "LE"}
69
70    def get_input_registers_list(self):
71        if self.is_conditional():
72            return self.operands[0].get_registers_list() + self.operands[1].get_registers_list() + self.operands[
73                2].get_registers_list()
74        else:
75            return self.operands[1].get_registers_list() + self.operands[2].get_registers_list()
76
77    def get_output_registers_list(self):
78        return self.operands[0].get_registers_list()
79
80
81class ShiftInstruction(Instruction):
82    def __init__(self, name, destination, source_x, source_y, origin=None):
83        allowed_instructions = ['LSL', 'LSR', 'ASR']
84        super(ShiftInstruction, self).__init__(name, [destination, source_x, source_y], origin=origin)
85        if name not in allowed_instructions:
86            raise ValueError('Instruction {0} is not one of the allowed instructions ({1})'
87                             .format(name, ", ".join(allowed_instructions)))
88        if destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_immediate5():
89            pass
90        elif destination.is_general_purpose_register() and source_x.is_general_purpose_register() and source_y.is_general_purpose_register():
91            pass
92        else:
93            raise ValueError('Invalid operands in instruction {0} {1}, {2}, {3}'
94                             .format(name, destination, source_x, source_y))
95
96    def get_input_registers_list(self):
97        return self.operands[1].get_registers_list() + self.operands[2].get_registers_list()
98
99    def get_output_registers_list(self):
100        return self.operands[0].get_registers_list()
101
102
103class CompareInstruction(Instruction):
104    def __init__(self, name, source_x, source_y, origin=None):
105        allowed_instructions = ['CMP', 'CMPEQ', 'CMPNE', 'CMPCS', 'CMPHS', 'CMPCC', 'CMPLO', 'CMPMI', 'CMPPL', 'CMPVS',
106                                'CMPVC', 'CMPHI', 'CMPLS', 'CMPGE', 'CMPLT', 'CMPGT', 'CMPLE',
107                                'TEQ', 'TEQEQ', 'TEQNE', 'TEQCS', 'TEQHS', 'TEQCC', 'TEQLO', 'TEQMI', 'TEQPL', 'TEQVS',
108                                'TEQVC', 'TEQHI', 'TEQLS', 'TEQGE', 'TEQLT', 'TEQGT', 'TEQLE',
109                                'TST', 'TSTEQ', 'TSTNE', 'TSTCS', 'TSTHS', 'TSTCC', 'TSTLO', 'TSTMI', 'TSTPL', 'TSTVS',
110                                'TSTVC', 'TSTHI', 'TSTLS', 'TSTGE', 'TSTLT', 'TSTGT', 'TSTLE',
111                                'TEQ', 'TEQEQ', 'TEQNE', 'TEQCS', 'TEQHS', 'TEQCC', 'TEQLO', 'TEQMI', 'TEQPL', 'TEQVS',
112                                'TEQVC', 'TEQHI', 'TEQLS', 'TEQGE', 'TEQLT', 'TEQGT', 'TEQLE']
113        if name in allowed_instructions:
114            super(CompareInstruction, self).__init__(name, [source_x, source_y], origin=origin)
115        else:
116            raise ValueError('Instruction {0} is not one of the allowed instructions ({1})'
117                             .format(name, ", ".join(allowed_instructions)))
118        if source_x.is_general_purpose_register() and source_y.is_modified_immediate12():
119            pass
120        elif source_x.is_general_purpose_register() and source_y.is_general_purpose_register():
121            pass
122        else:
123            raise ValueError('Invalid operands in instruction {0} {1}, {2}'.format(name, source_x, source_y))
124
125    def get_input_registers_list(self):
126        return self.operands[0].get_registers_list() + self.operands[1].get_registers_list()
127
128    def get_output_registers_list(self):
129        return list()
130
131
132class MovInstruction(Instruction):
133    def __init__(self, name, destination, source, origin=None):
134        allowed_instructions = ['MOV', 'MOVEQ', 'MOVNE', 'MOVCS', 'MOVHS', 'MOVCC', 'MOVLO', 'MOVMI', 'MOVPL', 'MOVVS',
135                                'MOVVC', 'MOVHI', 'MOVLS', 'MOVGE', 'MOVLT', 'MOVGT', 'MOVLE',
136                                'MOVS', 'MOVSEQ', 'MOVSNE', 'MOVSCS', 'MOVSHS', 'MOVSCC', 'MOVSLO', 'MOVSMI', 'MOVSPL',
137                                'MOVSVS', 'MOVSVC', 'MOVSHI', 'MOVSLS', 'MOVSGE', 'MOVSLT', 'MOVSGT', 'MOVSLE']
138        if name in allowed_instructions:
139            super(MovInstruction, self).__init__(name, [destination, source], origin=origin)
140        else:
141            raise ValueError('Instruction {0} is not one of the allowed instructions ({1})'
142                             .format(name, ", ".join(allowed_instructions)))
143        if destination.is_general_purpose_register() and source.is_modified_immediate12():
144            pass
145        elif destination.is_general_purpose_register() and source.is_general_purpose_register():
146            pass
147        else:
148            raise ValueError('Invalid operands in instruction {0} {1}, {2}'.format(name, destination, source))
149
150    def is_conditional(self):
151        return self.name[-2:] in {"EQ", "NE", "CS", "CC", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT",
152                                  "LE"}
153
154    def get_input_registers_list(self):
155        if self.is_conditional():
156            return self.operands[0].get_registers_list() + self.operands[1].get_registers_list()
157        else:
158            return self.operands[1].get_registers_list()
159
160    def get_output_registers_list(self):
161        return self.operands[0].get_registers_list()
162
163
164class LoadStoreInstruction(Instruction):
165    load_instructions = ['LDR', 'LDRH', 'LDRSH', 'LDRB', 'LDRSB']
166    store_instructions = ['STR', 'STRB', 'STRH']
167
168    def __init__(self, name, register, address, increment, origin=None):
169        allowed_instructions = LoadStoreInstruction.load_instructions + LoadStoreInstruction.store_instructions
170        if name not in allowed_instructions:
171            raise ValueError('Instruction {0} is not one of the allowed instructions ({1})'.format(name, ", ".join(
172                allowed_instructions)))
173        if register.is_general_purpose_register() and address.is_memory_address(offset_bits=8) and increment.is_none():
174            super(LoadStoreInstruction, self).__init__(name, [register, address], origin=origin)
175        elif name in {'STR', 'LDR', 'LDRB',
176                      'STRB'} and register.is_general_purpose_register() and address.is_memory_address(
177                offset_bits=12) and increment.is_none():
178            super(LoadStoreInstruction, self).__init__(name, [register, address], origin=origin)
179        elif register.is_general_purpose_register() and address.is_memory_address(offset_bits=0,
180                                                                                  allow_writeback=False) and increment.is_offset8():
181            super(LoadStoreInstruction, self).__init__(name, [register, address, increment], origin=origin)
182        elif register.is_general_purpose_register() and address.is_memory_address(offset_bits=0,
183                                                                                  allow_writeback=False) and increment.is_offset12():
184            super(LoadStoreInstruction, self).__init__(name, [register, address, increment], origin=origin)
185        else:
186            if increment.is_none():
187                raise ValueError('Invalid operands in instruction {0} {1}, {2}'.format(name, register, address))
188            else:
189                raise ValueError('Invalid operands in instruction {0} {1}, {2}, {3}'
190                                 .format(name, register, address, increment))
191
192    def get_input_registers_list(self):
193        input_registers_list = self.operands[
194            0].get_registers_list() if self.name in LoadStoreInstruction.store_instructions else list()
195        for operand in self.operands[1:]:
196            input_registers_list += operand.get_registers_list()
197        return input_registers_list
198
199    def get_output_registers_list(self):
200        output_registers_list = self.operands[
201            0].get_registers_list() if self.name in LoadStoreInstruction.load_instructions else list()
202        if len(self.operands) > 2 or self.operands[1].is_preindexed_memory_address():
203            output_registers_list.append(self.operands[1].base)
204        return output_registers_list
205
206
207class PushPopInstruction(Instruction):
208    def __init__(self, name, register_list, origin=None):
209        allowed_instructions = {'PUSH', 'POP'}
210        if name in allowed_instructions:
211            super(PushPopInstruction, self).__init__(name, [register_list], origin=origin)
212        else:
213            raise ValueError('Instruction {0} is not one of the allowed instructions'.format(name))
214        if register_list.is_general_purpose_register_list():
215            pass
216        else:
217            raise ValueError('Invalid operands in instruction {0} {1}'.format(name, register_list))
218
219    def get_input_registers_list(self):
220        if self.name == 'PUSH':
221            return self.operands[0].get_registers_list()
222        else:
223            return list()
224
225    def get_output_registers_list(self):
226        if self.name == 'POP':
227            return self.operands[0].get_registers_list()
228        else:
229            return list()
230
231
232class BranchInstruction(Instruction):
233    def __init__(self, name, destination, origin=None):
234        allowed_instructions = {'B', 'BEQ', 'BNE', 'BCS', 'BHS', 'BCC', 'BLO', 'BMI', 'BPL', 'BVS', 'BVC', 'BHI', 'BLS',
235                                'BGE', 'BLT', 'BGT', 'BLE'}
236        if name in allowed_instructions:
237            super(BranchInstruction, self).__init__(name, [destination], origin=origin)
238            self.is_visited = False
239        else:
240            raise ValueError('Instruction {0} is not one of the allowed instructions'.format(name))
241        if destination.is_label():
242            pass
243        else:
244            raise ValueError('Invalid operands in instruction {0} {1}'.format('BX', destination))
245
246    def get_input_registers_list(self):
247        return self.operands[0].get_registers_list()
248
249    def get_output_registers_list(self):
250        return list()
251
252    def is_conditional(self):
253        return not self.name == 'B'
254
255    def __str__(self):
256        return self.name + " L" + str(self.operands[0])
257
258
259class BranchExchangeInstruction(Instruction):
260    def __init__(self, destination, origin=None):
261        from peachpy.arm.registers import lr
262        super(BranchExchangeInstruction, self).__init__('BX', [destination], origin=origin)
263        if destination.is_general_purpose_register() and destination.register == lr:
264            pass
265        else:
266            raise ValueError('Invalid operands in instruction {0} {1}'.format('BX', destination))
267
268    def get_input_registers_list(self):
269        return self.operands[0].get_registers_list()
270
271    def get_output_registers_list(self):
272        return list()
273
274
275class BreakInstruction(Instruction):
276    def __init__(self, origin=None):
277        super(BreakInstruction, self).__init__('BKPT', (), origin=origin)
278
279    def __str__(self):
280        return "BKPT"
281
282    def get_input_registers_list(self):
283        return []
284
285    def get_output_registers_list(self):
286        return []
287
288    def get_constant(self):
289        return None
290
291    def get_local_variable(self):
292        return None
293
294
295def BX(destination):
296    instruction = BranchExchangeInstruction(Operand(destination))
297    if peachpy.stream.active_stream is not None:
298        peachpy.stream.active_stream.add_instruction(instruction)
299    return instruction
300
301
302def BKPT():
303    instruction = BreakInstruction()
304    if peachpy.stream.active_stream is not None:
305        peachpy.stream.active_stream.add_instruction(instruction)
306    return instruction
307
308
309def ADD(destination, source_x, source_y=None):
310    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
311    if source_y is None:
312        (destination, source_x, source_y) = (destination, destination, source_x)
313    instruction = ArithmeticInstruction('ADD', Operand(destination), Operand(source_x), Operand(source_y),
314                                        origin=origin)
315    if peachpy.stream.active_stream is not None:
316        peachpy.stream.active_stream.add_instruction(instruction)
317    return instruction
318
319
320def ADDEQ(destination, source_x, source_y=None):
321    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
322    if source_y is None:
323        (destination, source_x, source_y) = (destination, destination, source_x)
324    instruction = ArithmeticInstruction('ADDEQ', Operand(destination), Operand(source_x), Operand(source_y),
325                                        origin=origin)
326    if peachpy.stream.active_stream is not None:
327        peachpy.stream.active_stream.add_instruction(instruction)
328    return instruction
329
330
331def ADDNE(destination, source_x, source_y=None):
332    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
333    if source_y is None:
334        (destination, source_x, source_y) = (destination, destination, source_x)
335    instruction = ArithmeticInstruction('ADDNE', Operand(destination), Operand(source_x), Operand(source_y),
336                                        origin=origin)
337    if peachpy.stream.active_stream is not None:
338        peachpy.stream.active_stream.add_instruction(instruction)
339    return instruction
340
341
342def ADDCS(destination, source_x, source_y=None):
343    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
344    if source_y is None:
345        (destination, source_x, source_y) = (destination, destination, source_x)
346    instruction = ArithmeticInstruction('ADDCS', Operand(destination), Operand(source_x), Operand(source_y),
347                                        origin=origin)
348    if peachpy.stream.active_stream is not None:
349        peachpy.stream.active_stream.add_instruction(instruction)
350    return instruction
351
352
353def ADDHS(destination, source_x, source_y=None):
354    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
355    if source_y is None:
356        (destination, source_x, source_y) = (destination, destination, source_x)
357    instruction = ArithmeticInstruction('ADDHS', Operand(destination), Operand(source_x), Operand(source_y),
358                                        origin=origin)
359    if peachpy.stream.active_stream is not None:
360        peachpy.stream.active_stream.add_instruction(instruction)
361    return instruction
362
363
364def ADDCC(destination, source_x, source_y=None):
365    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
366    if source_y is None:
367        (destination, source_x, source_y) = (destination, destination, source_x)
368    instruction = ArithmeticInstruction('ADDCC', Operand(destination), Operand(source_x), Operand(source_y),
369                                        origin=origin)
370    if peachpy.stream.active_stream is not None:
371        peachpy.stream.active_stream.add_instruction(instruction)
372    return instruction
373
374
375def ADDLO(destination, source_x, source_y=None):
376    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
377    if source_y is None:
378        (destination, source_x, source_y) = (destination, destination, source_x)
379    instruction = ArithmeticInstruction('ADDLO', Operand(destination), Operand(source_x), Operand(source_y),
380                                        origin=origin)
381    if peachpy.stream.active_stream is not None:
382        peachpy.stream.active_stream.add_instruction(instruction)
383    return instruction
384
385
386def ADDMI(destination, source_x, source_y=None):
387    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
388    if source_y is None:
389        (destination, source_x, source_y) = (destination, destination, source_x)
390    instruction = ArithmeticInstruction('ADDMI', Operand(destination), Operand(source_x), Operand(source_y),
391                                        origin=origin)
392    if peachpy.stream.active_stream is not None:
393        peachpy.stream.active_stream.add_instruction(instruction)
394    return instruction
395
396
397def ADDPL(destination, source_x, source_y=None):
398    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
399    if source_y is None:
400        (destination, source_x, source_y) = (destination, destination, source_x)
401    instruction = ArithmeticInstruction('ADDPL', Operand(destination), Operand(source_x), Operand(source_y),
402                                        origin=origin)
403    if peachpy.stream.active_stream is not None:
404        peachpy.stream.active_stream.add_instruction(instruction)
405    return instruction
406
407
408def ADDVS(destination, source_x, source_y=None):
409    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
410    if source_y is None:
411        (destination, source_x, source_y) = (destination, destination, source_x)
412    instruction = ArithmeticInstruction('ADDVS', Operand(destination), Operand(source_x), Operand(source_y),
413                                        origin=origin)
414    if peachpy.stream.active_stream is not None:
415        peachpy.stream.active_stream.add_instruction(instruction)
416    return instruction
417
418
419def ADDVC(destination, source_x, source_y=None):
420    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
421    if source_y is None:
422        (destination, source_x, source_y) = (destination, destination, source_x)
423    instruction = ArithmeticInstruction('ADDVC', Operand(destination), Operand(source_x), Operand(source_y),
424                                        origin=origin)
425    if peachpy.stream.active_stream is not None:
426        peachpy.stream.active_stream.add_instruction(instruction)
427    return instruction
428
429
430def ADDHI(destination, source_x, source_y=None):
431    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
432    if source_y is None:
433        (destination, source_x, source_y) = (destination, destination, source_x)
434    instruction = ArithmeticInstruction('ADDHI', Operand(destination), Operand(source_x), Operand(source_y),
435                                        origin=origin)
436    if peachpy.stream.active_stream is not None:
437        peachpy.stream.active_stream.add_instruction(instruction)
438    return instruction
439
440
441def ADDLS(destination, source_x, source_y=None):
442    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
443    if source_y is None:
444        (destination, source_x, source_y) = (destination, destination, source_x)
445    instruction = ArithmeticInstruction('ADDLS', Operand(destination), Operand(source_x), Operand(source_y),
446                                        origin=origin)
447    if peachpy.stream.active_stream is not None:
448        peachpy.stream.active_stream.add_instruction(instruction)
449    return instruction
450
451
452def ADDGE(destination, source_x, source_y=None):
453    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
454    if source_y is None:
455        (destination, source_x, source_y) = (destination, destination, source_x)
456    instruction = ArithmeticInstruction('ADDGE', Operand(destination), Operand(source_x), Operand(source_y),
457                                        origin=origin)
458    if peachpy.stream.active_stream is not None:
459        peachpy.stream.active_stream.add_instruction(instruction)
460    return instruction
461
462
463def ADDLT(destination, source_x, source_y=None):
464    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
465    if source_y is None:
466        (destination, source_x, source_y) = (destination, destination, source_x)
467    instruction = ArithmeticInstruction('ADDLT', Operand(destination), Operand(source_x), Operand(source_y),
468                                        origin=origin)
469    if peachpy.stream.active_stream is not None:
470        peachpy.stream.active_stream.add_instruction(instruction)
471    return instruction
472
473
474def ADDGT(destination, source_x, source_y=None):
475    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
476    if source_y is None:
477        (destination, source_x, source_y) = (destination, destination, source_x)
478    instruction = ArithmeticInstruction('ADDGT', Operand(destination), Operand(source_x), Operand(source_y),
479                                        origin=origin)
480    if peachpy.stream.active_stream is not None:
481        peachpy.stream.active_stream.add_instruction(instruction)
482    return instruction
483
484
485def ADDLE(destination, source_x, source_y=None):
486    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
487    if source_y is None:
488        (destination, source_x, source_y) = (destination, destination, source_x)
489    instruction = ArithmeticInstruction('ADDLE', Operand(destination), Operand(source_x), Operand(source_y),
490                                        origin=origin)
491    if peachpy.stream.active_stream is not None:
492        peachpy.stream.active_stream.add_instruction(instruction)
493    return instruction
494
495
496def ADDS(destination, source_x, source_y=None):
497    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
498    if source_y is None:
499        (destination, source_x, source_y) = (destination, destination, source_x)
500    instruction = ArithmeticInstruction('ADDS', Operand(destination), Operand(source_x), Operand(source_y),
501                                        origin=origin)
502    if peachpy.stream.active_stream is not None:
503        peachpy.stream.active_stream.add_instruction(instruction)
504    return instruction
505
506
507def ADDSEQ(destination, source_x, source_y=None):
508    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
509    if source_y is None:
510        (destination, source_x, source_y) = (destination, destination, source_x)
511    instruction = ArithmeticInstruction('ADDSEQ', Operand(destination), Operand(source_x), Operand(source_y),
512                                        origin=origin)
513    if peachpy.stream.active_stream is not None:
514        peachpy.stream.active_stream.add_instruction(instruction)
515    return instruction
516
517
518def ADDSNE(destination, source_x, source_y=None):
519    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
520    if source_y is None:
521        (destination, source_x, source_y) = (destination, destination, source_x)
522    instruction = ArithmeticInstruction('ADDSNE', Operand(destination), Operand(source_x), Operand(source_y),
523                                        origin=origin)
524    if peachpy.stream.active_stream is not None:
525        peachpy.stream.active_stream.add_instruction(instruction)
526    return instruction
527
528
529def ADDSCS(destination, source_x, source_y=None):
530    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
531    if source_y is None:
532        (destination, source_x, source_y) = (destination, destination, source_x)
533    instruction = ArithmeticInstruction('ADDSCS', Operand(destination), Operand(source_x), Operand(source_y),
534                                        origin=origin)
535    if peachpy.stream.active_stream is not None:
536        peachpy.stream.active_stream.add_instruction(instruction)
537    return instruction
538
539
540def ADDSHS(destination, source_x, source_y=None):
541    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
542    if source_y is None:
543        (destination, source_x, source_y) = (destination, destination, source_x)
544    instruction = ArithmeticInstruction('ADDSHS', Operand(destination), Operand(source_x), Operand(source_y),
545                                        origin=origin)
546    if peachpy.stream.active_stream is not None:
547        peachpy.stream.active_stream.add_instruction(instruction)
548    return instruction
549
550
551def ADDSCC(destination, source_x, source_y=None):
552    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
553    if source_y is None:
554        (destination, source_x, source_y) = (destination, destination, source_x)
555    instruction = ArithmeticInstruction('ADDSCC', Operand(destination), Operand(source_x), Operand(source_y),
556                                        origin=origin)
557    if peachpy.stream.active_stream is not None:
558        peachpy.stream.active_stream.add_instruction(instruction)
559    return instruction
560
561
562def ADDSLO(destination, source_x, source_y=None):
563    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
564    if source_y is None:
565        (destination, source_x, source_y) = (destination, destination, source_x)
566    instruction = ArithmeticInstruction('ADDSLO', Operand(destination), Operand(source_x), Operand(source_y),
567                                        origin=origin)
568    if peachpy.stream.active_stream is not None:
569        peachpy.stream.active_stream.add_instruction(instruction)
570    return instruction
571
572
573def ADDSMI(destination, source_x, source_y=None):
574    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
575    if source_y is None:
576        (destination, source_x, source_y) = (destination, destination, source_x)
577    instruction = ArithmeticInstruction('ADDSMI', Operand(destination), Operand(source_x), Operand(source_y),
578                                        origin=origin)
579    if peachpy.stream.active_stream is not None:
580        peachpy.stream.active_stream.add_instruction(instruction)
581    return instruction
582
583
584def ADDSPL(destination, source_x, source_y=None):
585    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
586    if source_y is None:
587        (destination, source_x, source_y) = (destination, destination, source_x)
588    instruction = ArithmeticInstruction('ADDSPL', Operand(destination), Operand(source_x), Operand(source_y),
589                                        origin=origin)
590    if peachpy.stream.active_stream is not None:
591        peachpy.stream.active_stream.add_instruction(instruction)
592    return instruction
593
594
595def ADDSVS(destination, source_x, source_y=None):
596    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
597    if source_y is None:
598        (destination, source_x, source_y) = (destination, destination, source_x)
599    instruction = ArithmeticInstruction('ADDSVS', Operand(destination), Operand(source_x), Operand(source_y),
600                                        origin=origin)
601    if peachpy.stream.active_stream is not None:
602        peachpy.stream.active_stream.add_instruction(instruction)
603    return instruction
604
605
606def ADDSVC(destination, source_x, source_y=None):
607    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
608    if source_y is None:
609        (destination, source_x, source_y) = (destination, destination, source_x)
610    instruction = ArithmeticInstruction('ADDSVC', Operand(destination), Operand(source_x), Operand(source_y),
611                                        origin=origin)
612    if peachpy.stream.active_stream is not None:
613        peachpy.stream.active_stream.add_instruction(instruction)
614    return instruction
615
616
617def ADDSHI(destination, source_x, source_y=None):
618    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
619    if source_y is None:
620        (destination, source_x, source_y) = (destination, destination, source_x)
621    instruction = ArithmeticInstruction('ADDSHI', Operand(destination), Operand(source_x), Operand(source_y),
622                                        origin=origin)
623    if peachpy.stream.active_stream is not None:
624        peachpy.stream.active_stream.add_instruction(instruction)
625    return instruction
626
627
628def ADDSLS(destination, source_x, source_y=None):
629    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
630    if source_y is None:
631        (destination, source_x, source_y) = (destination, destination, source_x)
632    instruction = ArithmeticInstruction('ADDSLS', Operand(destination), Operand(source_x), Operand(source_y),
633                                        origin=origin)
634    if peachpy.stream.active_stream is not None:
635        peachpy.stream.active_stream.add_instruction(instruction)
636    return instruction
637
638
639def ADDSGE(destination, source_x, source_y=None):
640    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
641    if source_y is None:
642        (destination, source_x, source_y) = (destination, destination, source_x)
643    instruction = ArithmeticInstruction('ADDSGE', Operand(destination), Operand(source_x), Operand(source_y),
644                                        origin=origin)
645    if peachpy.stream.active_stream is not None:
646        peachpy.stream.active_stream.add_instruction(instruction)
647    return instruction
648
649
650def ADDSLT(destination, source_x, source_y=None):
651    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
652    if source_y is None:
653        (destination, source_x, source_y) = (destination, destination, source_x)
654    instruction = ArithmeticInstruction('ADDSLT', Operand(destination), Operand(source_x), Operand(source_y),
655                                        origin=origin)
656    if peachpy.stream.active_stream is not None:
657        peachpy.stream.active_stream.add_instruction(instruction)
658    return instruction
659
660
661def ADDSGT(destination, source_x, source_y=None):
662    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
663    if source_y is None:
664        (destination, source_x, source_y) = (destination, destination, source_x)
665    instruction = ArithmeticInstruction('ADDSGT', Operand(destination), Operand(source_x), Operand(source_y),
666                                        origin=origin)
667    if peachpy.stream.active_stream is not None:
668        peachpy.stream.active_stream.add_instruction(instruction)
669    return instruction
670
671
672def ADDSLE(destination, source_x, source_y=None):
673    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
674    if source_y is None:
675        (destination, source_x, source_y) = (destination, destination, source_x)
676    instruction = ArithmeticInstruction('ADDSLE', Operand(destination), Operand(source_x), Operand(source_y),
677                                        origin=origin)
678    if peachpy.stream.active_stream is not None:
679        peachpy.stream.active_stream.add_instruction(instruction)
680    return instruction
681
682
683def ADC(destination, source_x, source_y=None):
684    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
685    if source_y is None:
686        (destination, source_x, source_y) = (destination, destination, source_x)
687    instruction = ArithmeticInstruction('ADC', Operand(destination), Operand(source_x), Operand(source_y),
688                                        origin=origin)
689    if peachpy.stream.active_stream is not None:
690        peachpy.stream.active_stream.add_instruction(instruction)
691    return instruction
692
693
694def ADCEQ(destination, source_x, source_y=None):
695    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
696    if source_y is None:
697        (destination, source_x, source_y) = (destination, destination, source_x)
698    instruction = ArithmeticInstruction('ADCEQ', Operand(destination), Operand(source_x), Operand(source_y),
699                                        origin=origin)
700    if peachpy.stream.active_stream is not None:
701        peachpy.stream.active_stream.add_instruction(instruction)
702    return instruction
703
704
705def ADCNE(destination, source_x, source_y=None):
706    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
707    if source_y is None:
708        (destination, source_x, source_y) = (destination, destination, source_x)
709    instruction = ArithmeticInstruction('ADCNE', Operand(destination), Operand(source_x), Operand(source_y),
710                                        origin=origin)
711    if peachpy.stream.active_stream is not None:
712        peachpy.stream.active_stream.add_instruction(instruction)
713    return instruction
714
715
716def ADCCS(destination, source_x, source_y=None):
717    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
718    if source_y is None:
719        (destination, source_x, source_y) = (destination, destination, source_x)
720    instruction = ArithmeticInstruction('ADCCS', Operand(destination), Operand(source_x), Operand(source_y),
721                                        origin=origin)
722    if peachpy.stream.active_stream is not None:
723        peachpy.stream.active_stream.add_instruction(instruction)
724    return instruction
725
726
727def ADCHS(destination, source_x, source_y=None):
728    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
729    if source_y is None:
730        (destination, source_x, source_y) = (destination, destination, source_x)
731    instruction = ArithmeticInstruction('ADCHS', Operand(destination), Operand(source_x), Operand(source_y),
732                                        origin=origin)
733    if peachpy.stream.active_stream is not None:
734        peachpy.stream.active_stream.add_instruction(instruction)
735    return instruction
736
737
738def ADCCC(destination, source_x, source_y=None):
739    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
740    if source_y is None:
741        (destination, source_x, source_y) = (destination, destination, source_x)
742    instruction = ArithmeticInstruction('ADCCC', Operand(destination), Operand(source_x), Operand(source_y),
743                                        origin=origin)
744    if peachpy.stream.active_stream is not None:
745        peachpy.stream.active_stream.add_instruction(instruction)
746    return instruction
747
748
749def ADCLO(destination, source_x, source_y=None):
750    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
751    if source_y is None:
752        (destination, source_x, source_y) = (destination, destination, source_x)
753    instruction = ArithmeticInstruction('ADCLO', Operand(destination), Operand(source_x), Operand(source_y),
754                                        origin=origin)
755    if peachpy.stream.active_stream is not None:
756        peachpy.stream.active_stream.add_instruction(instruction)
757    return instruction
758
759
760def ADCMI(destination, source_x, source_y=None):
761    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
762    if source_y is None:
763        (destination, source_x, source_y) = (destination, destination, source_x)
764    instruction = ArithmeticInstruction('ADCMI', Operand(destination), Operand(source_x), Operand(source_y),
765                                        origin=origin)
766    if peachpy.stream.active_stream is not None:
767        peachpy.stream.active_stream.add_instruction(instruction)
768    return instruction
769
770
771def ADCPL(destination, source_x, source_y=None):
772    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
773    if source_y is None:
774        (destination, source_x, source_y) = (destination, destination, source_x)
775    instruction = ArithmeticInstruction('ADCPL', Operand(destination), Operand(source_x), Operand(source_y),
776                                        origin=origin)
777    if peachpy.stream.active_stream is not None:
778        peachpy.stream.active_stream.add_instruction(instruction)
779    return instruction
780
781
782def ADCVS(destination, source_x, source_y=None):
783    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
784    if source_y is None:
785        (destination, source_x, source_y) = (destination, destination, source_x)
786    instruction = ArithmeticInstruction('ADCVS', Operand(destination), Operand(source_x), Operand(source_y),
787                                        origin=origin)
788    if peachpy.stream.active_stream is not None:
789        peachpy.stream.active_stream.add_instruction(instruction)
790    return instruction
791
792
793def ADCVC(destination, source_x, source_y=None):
794    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
795    if source_y is None:
796        (destination, source_x, source_y) = (destination, destination, source_x)
797    instruction = ArithmeticInstruction('ADCVC', Operand(destination), Operand(source_x), Operand(source_y),
798                                        origin=origin)
799    if peachpy.stream.active_stream is not None:
800        peachpy.stream.active_stream.add_instruction(instruction)
801    return instruction
802
803
804def ADCHI(destination, source_x, source_y=None):
805    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
806    if source_y is None:
807        (destination, source_x, source_y) = (destination, destination, source_x)
808    instruction = ArithmeticInstruction('ADCHI', Operand(destination), Operand(source_x), Operand(source_y),
809                                        origin=origin)
810    if peachpy.stream.active_stream is not None:
811        peachpy.stream.active_stream.add_instruction(instruction)
812    return instruction
813
814
815def ADCLS(destination, source_x, source_y=None):
816    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
817    if source_y is None:
818        (destination, source_x, source_y) = (destination, destination, source_x)
819    instruction = ArithmeticInstruction('ADCLS', Operand(destination), Operand(source_x), Operand(source_y),
820                                        origin=origin)
821    if peachpy.stream.active_stream is not None:
822        peachpy.stream.active_stream.add_instruction(instruction)
823    return instruction
824
825
826def ADCGE(destination, source_x, source_y=None):
827    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
828    if source_y is None:
829        (destination, source_x, source_y) = (destination, destination, source_x)
830    instruction = ArithmeticInstruction('ADCGE', Operand(destination), Operand(source_x), Operand(source_y),
831                                        origin=origin)
832    if peachpy.stream.active_stream is not None:
833        peachpy.stream.active_stream.add_instruction(instruction)
834    return instruction
835
836
837def ADCLT(destination, source_x, source_y=None):
838    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
839    if source_y is None:
840        (destination, source_x, source_y) = (destination, destination, source_x)
841    instruction = ArithmeticInstruction('ADCLT', Operand(destination), Operand(source_x), Operand(source_y),
842                                        origin=origin)
843    if peachpy.stream.active_stream is not None:
844        peachpy.stream.active_stream.add_instruction(instruction)
845    return instruction
846
847
848def ADCGT(destination, source_x, source_y=None):
849    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
850    if source_y is None:
851        (destination, source_x, source_y) = (destination, destination, source_x)
852    instruction = ArithmeticInstruction('ADCGT', Operand(destination), Operand(source_x), Operand(source_y),
853                                        origin=origin)
854    if peachpy.stream.active_stream is not None:
855        peachpy.stream.active_stream.add_instruction(instruction)
856    return instruction
857
858
859def ADCLE(destination, source_x, source_y=None):
860    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
861    if source_y is None:
862        (destination, source_x, source_y) = (destination, destination, source_x)
863    instruction = ArithmeticInstruction('ADCLE', Operand(destination), Operand(source_x), Operand(source_y),
864                                        origin=origin)
865    if peachpy.stream.active_stream is not None:
866        peachpy.stream.active_stream.add_instruction(instruction)
867    return instruction
868
869
870def ADCS(destination, source_x, source_y=None):
871    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
872    if source_y is None:
873        (destination, source_x, source_y) = (destination, destination, source_x)
874    instruction = ArithmeticInstruction('ADCS', Operand(destination), Operand(source_x), Operand(source_y),
875                                        origin=origin)
876    if peachpy.stream.active_stream is not None:
877        peachpy.stream.active_stream.add_instruction(instruction)
878    return instruction
879
880
881def ADCSEQ(destination, source_x, source_y=None):
882    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
883    if source_y is None:
884        (destination, source_x, source_y) = (destination, destination, source_x)
885    instruction = ArithmeticInstruction('ADCSEQ', Operand(destination), Operand(source_x), Operand(source_y),
886                                        origin=origin)
887    if peachpy.stream.active_stream is not None:
888        peachpy.stream.active_stream.add_instruction(instruction)
889    return instruction
890
891
892def ADCSNE(destination, source_x, source_y=None):
893    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
894    if source_y is None:
895        (destination, source_x, source_y) = (destination, destination, source_x)
896    instruction = ArithmeticInstruction('ADCSNE', Operand(destination), Operand(source_x), Operand(source_y),
897                                        origin=origin)
898    if peachpy.stream.active_stream is not None:
899        peachpy.stream.active_stream.add_instruction(instruction)
900    return instruction
901
902
903def ADCSCS(destination, source_x, source_y=None):
904    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
905    if source_y is None:
906        (destination, source_x, source_y) = (destination, destination, source_x)
907    instruction = ArithmeticInstruction('ADCSCS', Operand(destination), Operand(source_x), Operand(source_y),
908                                        origin=origin)
909    if peachpy.stream.active_stream is not None:
910        peachpy.stream.active_stream.add_instruction(instruction)
911    return instruction
912
913
914def ADCSHS(destination, source_x, source_y=None):
915    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
916    if source_y is None:
917        (destination, source_x, source_y) = (destination, destination, source_x)
918    instruction = ArithmeticInstruction('ADCSHS', Operand(destination), Operand(source_x), Operand(source_y),
919                                        origin=origin)
920    if peachpy.stream.active_stream is not None:
921        peachpy.stream.active_stream.add_instruction(instruction)
922    return instruction
923
924
925def ADCSCC(destination, source_x, source_y=None):
926    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
927    if source_y is None:
928        (destination, source_x, source_y) = (destination, destination, source_x)
929    instruction = ArithmeticInstruction('ADCSCC', Operand(destination), Operand(source_x), Operand(source_y),
930                                        origin=origin)
931    if peachpy.stream.active_stream is not None:
932        peachpy.stream.active_stream.add_instruction(instruction)
933    return instruction
934
935
936def ADCSLO(destination, source_x, source_y=None):
937    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
938    if source_y is None:
939        (destination, source_x, source_y) = (destination, destination, source_x)
940    instruction = ArithmeticInstruction('ADCSLO', Operand(destination), Operand(source_x), Operand(source_y),
941                                        origin=origin)
942    if peachpy.stream.active_stream is not None:
943        peachpy.stream.active_stream.add_instruction(instruction)
944    return instruction
945
946
947def ADCSMI(destination, source_x, source_y=None):
948    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
949    if source_y is None:
950        (destination, source_x, source_y) = (destination, destination, source_x)
951    instruction = ArithmeticInstruction('ADCSMI', Operand(destination), Operand(source_x), Operand(source_y),
952                                        origin=origin)
953    if peachpy.stream.active_stream is not None:
954        peachpy.stream.active_stream.add_instruction(instruction)
955    return instruction
956
957
958def ADCSPL(destination, source_x, source_y=None):
959    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
960    if source_y is None:
961        (destination, source_x, source_y) = (destination, destination, source_x)
962    instruction = ArithmeticInstruction('ADCSPL', Operand(destination), Operand(source_x), Operand(source_y),
963                                        origin=origin)
964    if peachpy.stream.active_stream is not None:
965        peachpy.stream.active_stream.add_instruction(instruction)
966    return instruction
967
968
969def ADCSVS(destination, source_x, source_y=None):
970    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
971    if source_y is None:
972        (destination, source_x, source_y) = (destination, destination, source_x)
973    instruction = ArithmeticInstruction('ADCSVS', Operand(destination), Operand(source_x), Operand(source_y),
974                                        origin=origin)
975    if peachpy.stream.active_stream is not None:
976        peachpy.stream.active_stream.add_instruction(instruction)
977    return instruction
978
979
980def ADCSVC(destination, source_x, source_y=None):
981    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
982    if source_y is None:
983        (destination, source_x, source_y) = (destination, destination, source_x)
984    instruction = ArithmeticInstruction('ADCSVC', Operand(destination), Operand(source_x), Operand(source_y),
985                                        origin=origin)
986    if peachpy.stream.active_stream is not None:
987        peachpy.stream.active_stream.add_instruction(instruction)
988    return instruction
989
990
991def ADCSHI(destination, source_x, source_y=None):
992    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
993    if source_y is None:
994        (destination, source_x, source_y) = (destination, destination, source_x)
995    instruction = ArithmeticInstruction('ADCSHI', Operand(destination), Operand(source_x), Operand(source_y),
996                                        origin=origin)
997    if peachpy.stream.active_stream is not None:
998        peachpy.stream.active_stream.add_instruction(instruction)
999    return instruction
1000
1001
1002def ADCSLS(destination, source_x, source_y=None):
1003    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1004    if source_y is None:
1005        (destination, source_x, source_y) = (destination, destination, source_x)
1006    instruction = ArithmeticInstruction('ADCSLS', Operand(destination), Operand(source_x), Operand(source_y),
1007                                        origin=origin)
1008    if peachpy.stream.active_stream is not None:
1009        peachpy.stream.active_stream.add_instruction(instruction)
1010    return instruction
1011
1012
1013def ADCSGE(destination, source_x, source_y=None):
1014    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1015    if source_y is None:
1016        (destination, source_x, source_y) = (destination, destination, source_x)
1017    instruction = ArithmeticInstruction('ADCSGE', Operand(destination), Operand(source_x), Operand(source_y),
1018                                        origin=origin)
1019    if peachpy.stream.active_stream is not None:
1020        peachpy.stream.active_stream.add_instruction(instruction)
1021    return instruction
1022
1023
1024def ADCSLT(destination, source_x, source_y=None):
1025    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1026    if source_y is None:
1027        (destination, source_x, source_y) = (destination, destination, source_x)
1028    instruction = ArithmeticInstruction('ADCSLT', Operand(destination), Operand(source_x), Operand(source_y),
1029                                        origin=origin)
1030    if peachpy.stream.active_stream is not None:
1031        peachpy.stream.active_stream.add_instruction(instruction)
1032    return instruction
1033
1034
1035def ADCSGT(destination, source_x, source_y=None):
1036    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1037    if source_y is None:
1038        (destination, source_x, source_y) = (destination, destination, source_x)
1039    instruction = ArithmeticInstruction('ADCSGT', Operand(destination), Operand(source_x), Operand(source_y),
1040                                        origin=origin)
1041    if peachpy.stream.active_stream is not None:
1042        peachpy.stream.active_stream.add_instruction(instruction)
1043    return instruction
1044
1045
1046def ADCSLE(destination, source_x, source_y=None):
1047    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1048    if source_y is None:
1049        (destination, source_x, source_y) = (destination, destination, source_x)
1050    instruction = ArithmeticInstruction('ADCSLE', Operand(destination), Operand(source_x), Operand(source_y),
1051                                        origin=origin)
1052    if peachpy.stream.active_stream is not None:
1053        peachpy.stream.active_stream.add_instruction(instruction)
1054    return instruction
1055
1056
1057def SUB(destination, source_x, source_y=None):
1058    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1059    if source_y is None:
1060        (destination, source_x, source_y) = (destination, destination, source_x)
1061    instruction = ArithmeticInstruction('SUB', Operand(destination), Operand(source_x), Operand(source_y),
1062                                        origin=origin)
1063    if peachpy.stream.active_stream is not None:
1064        peachpy.stream.active_stream.add_instruction(instruction)
1065    return instruction
1066
1067
1068def SUBEQ(destination, source_x, source_y=None):
1069    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1070    if source_y is None:
1071        (destination, source_x, source_y) = (destination, destination, source_x)
1072    instruction = ArithmeticInstruction('SUBEQ', Operand(destination), Operand(source_x), Operand(source_y),
1073                                        origin=origin)
1074    if peachpy.stream.active_stream is not None:
1075        peachpy.stream.active_stream.add_instruction(instruction)
1076    return instruction
1077
1078
1079def SUBNE(destination, source_x, source_y=None):
1080    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1081    if source_y is None:
1082        (destination, source_x, source_y) = (destination, destination, source_x)
1083    instruction = ArithmeticInstruction('SUBNE', Operand(destination), Operand(source_x), Operand(source_y),
1084                                        origin=origin)
1085    if peachpy.stream.active_stream is not None:
1086        peachpy.stream.active_stream.add_instruction(instruction)
1087    return instruction
1088
1089
1090def SUBCS(destination, source_x, source_y=None):
1091    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1092    if source_y is None:
1093        (destination, source_x, source_y) = (destination, destination, source_x)
1094    instruction = ArithmeticInstruction('SUBCS', Operand(destination), Operand(source_x), Operand(source_y),
1095                                        origin=origin)
1096    if peachpy.stream.active_stream is not None:
1097        peachpy.stream.active_stream.add_instruction(instruction)
1098    return instruction
1099
1100
1101def SUBHS(destination, source_x, source_y=None):
1102    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1103    if source_y is None:
1104        (destination, source_x, source_y) = (destination, destination, source_x)
1105    instruction = ArithmeticInstruction('SUBHS', Operand(destination), Operand(source_x), Operand(source_y),
1106                                        origin=origin)
1107    if peachpy.stream.active_stream is not None:
1108        peachpy.stream.active_stream.add_instruction(instruction)
1109    return instruction
1110
1111
1112def SUBCC(destination, source_x, source_y=None):
1113    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1114    if source_y is None:
1115        (destination, source_x, source_y) = (destination, destination, source_x)
1116    instruction = ArithmeticInstruction('SUBCC', Operand(destination), Operand(source_x), Operand(source_y),
1117                                        origin=origin)
1118    if peachpy.stream.active_stream is not None:
1119        peachpy.stream.active_stream.add_instruction(instruction)
1120    return instruction
1121
1122
1123def SUBLO(destination, source_x, source_y=None):
1124    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1125    if source_y is None:
1126        (destination, source_x, source_y) = (destination, destination, source_x)
1127    instruction = ArithmeticInstruction('SUBLO', Operand(destination), Operand(source_x), Operand(source_y),
1128                                        origin=origin)
1129    if peachpy.stream.active_stream is not None:
1130        peachpy.stream.active_stream.add_instruction(instruction)
1131    return instruction
1132
1133
1134def SUBMI(destination, source_x, source_y=None):
1135    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1136    if source_y is None:
1137        (destination, source_x, source_y) = (destination, destination, source_x)
1138    instruction = ArithmeticInstruction('SUBMI', Operand(destination), Operand(source_x), Operand(source_y),
1139                                        origin=origin)
1140    if peachpy.stream.active_stream is not None:
1141        peachpy.stream.active_stream.add_instruction(instruction)
1142    return instruction
1143
1144
1145def SUBPL(destination, source_x, source_y=None):
1146    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1147    if source_y is None:
1148        (destination, source_x, source_y) = (destination, destination, source_x)
1149    instruction = ArithmeticInstruction('SUBPL', Operand(destination), Operand(source_x), Operand(source_y),
1150                                        origin=origin)
1151    if peachpy.stream.active_stream is not None:
1152        peachpy.stream.active_stream.add_instruction(instruction)
1153    return instruction
1154
1155
1156def SUBVS(destination, source_x, source_y=None):
1157    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1158    if source_y is None:
1159        (destination, source_x, source_y) = (destination, destination, source_x)
1160    instruction = ArithmeticInstruction('SUBVS', Operand(destination), Operand(source_x), Operand(source_y),
1161                                        origin=origin)
1162    if peachpy.stream.active_stream is not None:
1163        peachpy.stream.active_stream.add_instruction(instruction)
1164    return instruction
1165
1166
1167def SUBVC(destination, source_x, source_y=None):
1168    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1169    if source_y is None:
1170        (destination, source_x, source_y) = (destination, destination, source_x)
1171    instruction = ArithmeticInstruction('SUBVC', Operand(destination), Operand(source_x), Operand(source_y),
1172                                        origin=origin)
1173    if peachpy.stream.active_stream is not None:
1174        peachpy.stream.active_stream.add_instruction(instruction)
1175    return instruction
1176
1177
1178def SUBHI(destination, source_x, source_y=None):
1179    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1180    if source_y is None:
1181        (destination, source_x, source_y) = (destination, destination, source_x)
1182    instruction = ArithmeticInstruction('SUBHI', Operand(destination), Operand(source_x), Operand(source_y),
1183                                        origin=origin)
1184    if peachpy.stream.active_stream is not None:
1185        peachpy.stream.active_stream.add_instruction(instruction)
1186    return instruction
1187
1188
1189def SUBLS(destination, source_x, source_y=None):
1190    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1191    if source_y is None:
1192        (destination, source_x, source_y) = (destination, destination, source_x)
1193    instruction = ArithmeticInstruction('SUBLS', Operand(destination), Operand(source_x), Operand(source_y),
1194                                        origin=origin)
1195    if peachpy.stream.active_stream is not None:
1196        peachpy.stream.active_stream.add_instruction(instruction)
1197    return instruction
1198
1199
1200def SUBGE(destination, source_x, source_y=None):
1201    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1202    if source_y is None:
1203        (destination, source_x, source_y) = (destination, destination, source_x)
1204    instruction = ArithmeticInstruction('SUBGE', Operand(destination), Operand(source_x), Operand(source_y),
1205                                        origin=origin)
1206    if peachpy.stream.active_stream is not None:
1207        peachpy.stream.active_stream.add_instruction(instruction)
1208    return instruction
1209
1210
1211def SUBLT(destination, source_x, source_y=None):
1212    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1213    if source_y is None:
1214        (destination, source_x, source_y) = (destination, destination, source_x)
1215    instruction = ArithmeticInstruction('SUBLT', Operand(destination), Operand(source_x), Operand(source_y),
1216                                        origin=origin)
1217    if peachpy.stream.active_stream is not None:
1218        peachpy.stream.active_stream.add_instruction(instruction)
1219    return instruction
1220
1221
1222def SUBGT(destination, source_x, source_y=None):
1223    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1224    if source_y is None:
1225        (destination, source_x, source_y) = (destination, destination, source_x)
1226    instruction = ArithmeticInstruction('SUBGT', Operand(destination), Operand(source_x), Operand(source_y),
1227                                        origin=origin)
1228    if peachpy.stream.active_stream is not None:
1229        peachpy.stream.active_stream.add_instruction(instruction)
1230    return instruction
1231
1232
1233def SUBLE(destination, source_x, source_y=None):
1234    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1235    if source_y is None:
1236        (destination, source_x, source_y) = (destination, destination, source_x)
1237    instruction = ArithmeticInstruction('SUBLE', Operand(destination), Operand(source_x), Operand(source_y),
1238                                        origin=origin)
1239    if peachpy.stream.active_stream is not None:
1240        peachpy.stream.active_stream.add_instruction(instruction)
1241    return instruction
1242
1243
1244def SUBS(destination, source_x, source_y=None):
1245    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1246    if source_y is None:
1247        (destination, source_x, source_y) = (destination, destination, source_x)
1248    instruction = ArithmeticInstruction('SUBS', Operand(destination), Operand(source_x), Operand(source_y),
1249                                        origin=origin)
1250    if peachpy.stream.active_stream is not None:
1251        peachpy.stream.active_stream.add_instruction(instruction)
1252    return instruction
1253
1254
1255def SUBSEQ(destination, source_x, source_y=None):
1256    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1257    if source_y is None:
1258        (destination, source_x, source_y) = (destination, destination, source_x)
1259    instruction = ArithmeticInstruction('SUBSEQ', Operand(destination), Operand(source_x), Operand(source_y),
1260                                        origin=origin)
1261    if peachpy.stream.active_stream is not None:
1262        peachpy.stream.active_stream.add_instruction(instruction)
1263    return instruction
1264
1265
1266def SUBSNE(destination, source_x, source_y=None):
1267    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1268    if source_y is None:
1269        (destination, source_x, source_y) = (destination, destination, source_x)
1270    instruction = ArithmeticInstruction('SUBSNE', Operand(destination), Operand(source_x), Operand(source_y),
1271                                        origin=origin)
1272    if peachpy.stream.active_stream is not None:
1273        peachpy.stream.active_stream.add_instruction(instruction)
1274    return instruction
1275
1276
1277def SUBSCS(destination, source_x, source_y=None):
1278    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1279    if source_y is None:
1280        (destination, source_x, source_y) = (destination, destination, source_x)
1281    instruction = ArithmeticInstruction('SUBSCS', Operand(destination), Operand(source_x), Operand(source_y),
1282                                        origin=origin)
1283    if peachpy.stream.active_stream is not None:
1284        peachpy.stream.active_stream.add_instruction(instruction)
1285    return instruction
1286
1287
1288def SUBSHS(destination, source_x, source_y=None):
1289    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1290    if source_y is None:
1291        (destination, source_x, source_y) = (destination, destination, source_x)
1292    instruction = ArithmeticInstruction('SUBSHS', Operand(destination), Operand(source_x), Operand(source_y),
1293                                        origin=origin)
1294    if peachpy.stream.active_stream is not None:
1295        peachpy.stream.active_stream.add_instruction(instruction)
1296    return instruction
1297
1298
1299def SUBSCC(destination, source_x, source_y=None):
1300    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1301    if source_y is None:
1302        (destination, source_x, source_y) = (destination, destination, source_x)
1303    instruction = ArithmeticInstruction('SUBSCC', Operand(destination), Operand(source_x), Operand(source_y),
1304                                        origin=origin)
1305    if peachpy.stream.active_stream is not None:
1306        peachpy.stream.active_stream.add_instruction(instruction)
1307    return instruction
1308
1309
1310def SUBSLO(destination, source_x, source_y=None):
1311    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1312    if source_y is None:
1313        (destination, source_x, source_y) = (destination, destination, source_x)
1314    instruction = ArithmeticInstruction('SUBSLO', Operand(destination), Operand(source_x), Operand(source_y),
1315                                        origin=origin)
1316    if peachpy.stream.active_stream is not None:
1317        peachpy.stream.active_stream.add_instruction(instruction)
1318    return instruction
1319
1320
1321def SUBSMI(destination, source_x, source_y=None):
1322    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1323    if source_y is None:
1324        (destination, source_x, source_y) = (destination, destination, source_x)
1325    instruction = ArithmeticInstruction('SUBSMI', Operand(destination), Operand(source_x), Operand(source_y),
1326                                        origin=origin)
1327    if peachpy.stream.active_stream is not None:
1328        peachpy.stream.active_stream.add_instruction(instruction)
1329    return instruction
1330
1331
1332def SUBSPL(destination, source_x, source_y=None):
1333    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1334    if source_y is None:
1335        (destination, source_x, source_y) = (destination, destination, source_x)
1336    instruction = ArithmeticInstruction('SUBSPL', Operand(destination), Operand(source_x), Operand(source_y),
1337                                        origin=origin)
1338    if peachpy.stream.active_stream is not None:
1339        peachpy.stream.active_stream.add_instruction(instruction)
1340    return instruction
1341
1342
1343def SUBSVS(destination, source_x, source_y=None):
1344    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1345    if source_y is None:
1346        (destination, source_x, source_y) = (destination, destination, source_x)
1347    instruction = ArithmeticInstruction('SUBSVS', Operand(destination), Operand(source_x), Operand(source_y),
1348                                        origin=origin)
1349    if peachpy.stream.active_stream is not None:
1350        peachpy.stream.active_stream.add_instruction(instruction)
1351    return instruction
1352
1353
1354def SUBSVC(destination, source_x, source_y=None):
1355    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1356    if source_y is None:
1357        (destination, source_x, source_y) = (destination, destination, source_x)
1358    instruction = ArithmeticInstruction('SUBSVC', Operand(destination), Operand(source_x), Operand(source_y),
1359                                        origin=origin)
1360    if peachpy.stream.active_stream is not None:
1361        peachpy.stream.active_stream.add_instruction(instruction)
1362    return instruction
1363
1364
1365def SUBSHI(destination, source_x, source_y=None):
1366    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1367    if source_y is None:
1368        (destination, source_x, source_y) = (destination, destination, source_x)
1369    instruction = ArithmeticInstruction('SUBSHI', Operand(destination), Operand(source_x), Operand(source_y),
1370                                        origin=origin)
1371    if peachpy.stream.active_stream is not None:
1372        peachpy.stream.active_stream.add_instruction(instruction)
1373    return instruction
1374
1375
1376def SUBSLS(destination, source_x, source_y=None):
1377    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1378    if source_y is None:
1379        (destination, source_x, source_y) = (destination, destination, source_x)
1380    instruction = ArithmeticInstruction('SUBSLS', Operand(destination), Operand(source_x), Operand(source_y),
1381                                        origin=origin)
1382    if peachpy.stream.active_stream is not None:
1383        peachpy.stream.active_stream.add_instruction(instruction)
1384    return instruction
1385
1386
1387def SUBSGE(destination, source_x, source_y=None):
1388    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1389    if source_y is None:
1390        (destination, source_x, source_y) = (destination, destination, source_x)
1391    instruction = ArithmeticInstruction('SUBSGE', Operand(destination), Operand(source_x), Operand(source_y),
1392                                        origin=origin)
1393    if peachpy.stream.active_stream is not None:
1394        peachpy.stream.active_stream.add_instruction(instruction)
1395    return instruction
1396
1397
1398def SUBSLT(destination, source_x, source_y=None):
1399    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1400    if source_y is None:
1401        (destination, source_x, source_y) = (destination, destination, source_x)
1402    instruction = ArithmeticInstruction('SUBSLT', Operand(destination), Operand(source_x), Operand(source_y),
1403                                        origin=origin)
1404    if peachpy.stream.active_stream is not None:
1405        peachpy.stream.active_stream.add_instruction(instruction)
1406    return instruction
1407
1408
1409def SUBSGT(destination, source_x, source_y=None):
1410    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1411    if source_y is None:
1412        (destination, source_x, source_y) = (destination, destination, source_x)
1413    instruction = ArithmeticInstruction('SUBSGT', Operand(destination), Operand(source_x), Operand(source_y),
1414                                        origin=origin)
1415    if peachpy.stream.active_stream is not None:
1416        peachpy.stream.active_stream.add_instruction(instruction)
1417    return instruction
1418
1419
1420def SUBSLE(destination, source_x, source_y=None):
1421    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1422    if source_y is None:
1423        (destination, source_x, source_y) = (destination, destination, source_x)
1424    instruction = ArithmeticInstruction('SUBSLE', Operand(destination), Operand(source_x), Operand(source_y),
1425                                        origin=origin)
1426    if peachpy.stream.active_stream is not None:
1427        peachpy.stream.active_stream.add_instruction(instruction)
1428    return instruction
1429
1430
1431def SBC(destination, source_x, source_y=None):
1432    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1433    if source_y is None:
1434        (destination, source_x, source_y) = (destination, destination, source_x)
1435    instruction = ArithmeticInstruction('SBC', Operand(destination), Operand(source_x), Operand(source_y),
1436                                        origin=origin)
1437    if peachpy.stream.active_stream is not None:
1438        peachpy.stream.active_stream.add_instruction(instruction)
1439    return instruction
1440
1441
1442def SBCEQ(destination, source_x, source_y=None):
1443    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1444    if source_y is None:
1445        (destination, source_x, source_y) = (destination, destination, source_x)
1446    instruction = ArithmeticInstruction('SBCEQ', Operand(destination), Operand(source_x), Operand(source_y),
1447                                        origin=origin)
1448    if peachpy.stream.active_stream is not None:
1449        peachpy.stream.active_stream.add_instruction(instruction)
1450    return instruction
1451
1452
1453def SBCNE(destination, source_x, source_y=None):
1454    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1455    if source_y is None:
1456        (destination, source_x, source_y) = (destination, destination, source_x)
1457    instruction = ArithmeticInstruction('SBCNE', Operand(destination), Operand(source_x), Operand(source_y),
1458                                        origin=origin)
1459    if peachpy.stream.active_stream is not None:
1460        peachpy.stream.active_stream.add_instruction(instruction)
1461    return instruction
1462
1463
1464def SBCCS(destination, source_x, source_y=None):
1465    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1466    if source_y is None:
1467        (destination, source_x, source_y) = (destination, destination, source_x)
1468    instruction = ArithmeticInstruction('SBCCS', Operand(destination), Operand(source_x), Operand(source_y),
1469                                        origin=origin)
1470    if peachpy.stream.active_stream is not None:
1471        peachpy.stream.active_stream.add_instruction(instruction)
1472    return instruction
1473
1474
1475def SBCHS(destination, source_x, source_y=None):
1476    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1477    if source_y is None:
1478        (destination, source_x, source_y) = (destination, destination, source_x)
1479    instruction = ArithmeticInstruction('SBCHS', Operand(destination), Operand(source_x), Operand(source_y),
1480                                        origin=origin)
1481    if peachpy.stream.active_stream is not None:
1482        peachpy.stream.active_stream.add_instruction(instruction)
1483    return instruction
1484
1485
1486def SBCCC(destination, source_x, source_y=None):
1487    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1488    if source_y is None:
1489        (destination, source_x, source_y) = (destination, destination, source_x)
1490    instruction = ArithmeticInstruction('SBCCC', Operand(destination), Operand(source_x), Operand(source_y),
1491                                        origin=origin)
1492    if peachpy.stream.active_stream is not None:
1493        peachpy.stream.active_stream.add_instruction(instruction)
1494    return instruction
1495
1496
1497def SBCLO(destination, source_x, source_y=None):
1498    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1499    if source_y is None:
1500        (destination, source_x, source_y) = (destination, destination, source_x)
1501    instruction = ArithmeticInstruction('SBCLO', Operand(destination), Operand(source_x), Operand(source_y),
1502                                        origin=origin)
1503    if peachpy.stream.active_stream is not None:
1504        peachpy.stream.active_stream.add_instruction(instruction)
1505    return instruction
1506
1507
1508def SBCMI(destination, source_x, source_y=None):
1509    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1510    if source_y is None:
1511        (destination, source_x, source_y) = (destination, destination, source_x)
1512    instruction = ArithmeticInstruction('SBCMI', Operand(destination), Operand(source_x), Operand(source_y),
1513                                        origin=origin)
1514    if peachpy.stream.active_stream is not None:
1515        peachpy.stream.active_stream.add_instruction(instruction)
1516    return instruction
1517
1518
1519def SBCPL(destination, source_x, source_y=None):
1520    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1521    if source_y is None:
1522        (destination, source_x, source_y) = (destination, destination, source_x)
1523    instruction = ArithmeticInstruction('SBCPL', Operand(destination), Operand(source_x), Operand(source_y),
1524                                        origin=origin)
1525    if peachpy.stream.active_stream is not None:
1526        peachpy.stream.active_stream.add_instruction(instruction)
1527    return instruction
1528
1529
1530def SBCVS(destination, source_x, source_y=None):
1531    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1532    if source_y is None:
1533        (destination, source_x, source_y) = (destination, destination, source_x)
1534    instruction = ArithmeticInstruction('SBCVS', Operand(destination), Operand(source_x), Operand(source_y),
1535                                        origin=origin)
1536    if peachpy.stream.active_stream is not None:
1537        peachpy.stream.active_stream.add_instruction(instruction)
1538    return instruction
1539
1540
1541def SBCVC(destination, source_x, source_y=None):
1542    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1543    if source_y is None:
1544        (destination, source_x, source_y) = (destination, destination, source_x)
1545    instruction = ArithmeticInstruction('SBCVC', Operand(destination), Operand(source_x), Operand(source_y),
1546                                        origin=origin)
1547    if peachpy.stream.active_stream is not None:
1548        peachpy.stream.active_stream.add_instruction(instruction)
1549    return instruction
1550
1551
1552def SBCHI(destination, source_x, source_y=None):
1553    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1554    if source_y is None:
1555        (destination, source_x, source_y) = (destination, destination, source_x)
1556    instruction = ArithmeticInstruction('SBCHI', Operand(destination), Operand(source_x), Operand(source_y),
1557                                        origin=origin)
1558    if peachpy.stream.active_stream is not None:
1559        peachpy.stream.active_stream.add_instruction(instruction)
1560    return instruction
1561
1562
1563def SBCLS(destination, source_x, source_y=None):
1564    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1565    if source_y is None:
1566        (destination, source_x, source_y) = (destination, destination, source_x)
1567    instruction = ArithmeticInstruction('SBCLS', Operand(destination), Operand(source_x), Operand(source_y),
1568                                        origin=origin)
1569    if peachpy.stream.active_stream is not None:
1570        peachpy.stream.active_stream.add_instruction(instruction)
1571    return instruction
1572
1573
1574def SBCGE(destination, source_x, source_y=None):
1575    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1576    if source_y is None:
1577        (destination, source_x, source_y) = (destination, destination, source_x)
1578    instruction = ArithmeticInstruction('SBCGE', Operand(destination), Operand(source_x), Operand(source_y),
1579                                        origin=origin)
1580    if peachpy.stream.active_stream is not None:
1581        peachpy.stream.active_stream.add_instruction(instruction)
1582    return instruction
1583
1584
1585def SBCLT(destination, source_x, source_y=None):
1586    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1587    if source_y is None:
1588        (destination, source_x, source_y) = (destination, destination, source_x)
1589    instruction = ArithmeticInstruction('SBCLT', Operand(destination), Operand(source_x), Operand(source_y),
1590                                        origin=origin)
1591    if peachpy.stream.active_stream is not None:
1592        peachpy.stream.active_stream.add_instruction(instruction)
1593    return instruction
1594
1595
1596def SBCGT(destination, source_x, source_y=None):
1597    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1598    if source_y is None:
1599        (destination, source_x, source_y) = (destination, destination, source_x)
1600    instruction = ArithmeticInstruction('SBCGT', Operand(destination), Operand(source_x), Operand(source_y),
1601                                        origin=origin)
1602    if peachpy.stream.active_stream is not None:
1603        peachpy.stream.active_stream.add_instruction(instruction)
1604    return instruction
1605
1606
1607def SBCLE(destination, source_x, source_y=None):
1608    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1609    if source_y is None:
1610        (destination, source_x, source_y) = (destination, destination, source_x)
1611    instruction = ArithmeticInstruction('SBCLE', Operand(destination), Operand(source_x), Operand(source_y),
1612                                        origin=origin)
1613    if peachpy.stream.active_stream is not None:
1614        peachpy.stream.active_stream.add_instruction(instruction)
1615    return instruction
1616
1617
1618def SBCS(destination, source_x, source_y=None):
1619    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1620    if source_y is None:
1621        (destination, source_x, source_y) = (destination, destination, source_x)
1622    instruction = ArithmeticInstruction('SBCS', Operand(destination), Operand(source_x), Operand(source_y),
1623                                        origin=origin)
1624    if peachpy.stream.active_stream is not None:
1625        peachpy.stream.active_stream.add_instruction(instruction)
1626    return instruction
1627
1628
1629def SBCSEQ(destination, source_x, source_y=None):
1630    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1631    if source_y is None:
1632        (destination, source_x, source_y) = (destination, destination, source_x)
1633    instruction = ArithmeticInstruction('SBCSEQ', Operand(destination), Operand(source_x), Operand(source_y),
1634                                        origin=origin)
1635    if peachpy.stream.active_stream is not None:
1636        peachpy.stream.active_stream.add_instruction(instruction)
1637    return instruction
1638
1639
1640def SBCSNE(destination, source_x, source_y=None):
1641    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1642    if source_y is None:
1643        (destination, source_x, source_y) = (destination, destination, source_x)
1644    instruction = ArithmeticInstruction('SBCSNE', Operand(destination), Operand(source_x), Operand(source_y),
1645                                        origin=origin)
1646    if peachpy.stream.active_stream is not None:
1647        peachpy.stream.active_stream.add_instruction(instruction)
1648    return instruction
1649
1650
1651def SBCSCS(destination, source_x, source_y=None):
1652    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1653    if source_y is None:
1654        (destination, source_x, source_y) = (destination, destination, source_x)
1655    instruction = ArithmeticInstruction('SBCSCS', Operand(destination), Operand(source_x), Operand(source_y),
1656                                        origin=origin)
1657    if peachpy.stream.active_stream is not None:
1658        peachpy.stream.active_stream.add_instruction(instruction)
1659    return instruction
1660
1661
1662def SBCSHS(destination, source_x, source_y=None):
1663    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1664    if source_y is None:
1665        (destination, source_x, source_y) = (destination, destination, source_x)
1666    instruction = ArithmeticInstruction('SBCSHS', Operand(destination), Operand(source_x), Operand(source_y),
1667                                        origin=origin)
1668    if peachpy.stream.active_stream is not None:
1669        peachpy.stream.active_stream.add_instruction(instruction)
1670    return instruction
1671
1672
1673def SBCSCC(destination, source_x, source_y=None):
1674    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1675    if source_y is None:
1676        (destination, source_x, source_y) = (destination, destination, source_x)
1677    instruction = ArithmeticInstruction('SBCSCC', Operand(destination), Operand(source_x), Operand(source_y),
1678                                        origin=origin)
1679    if peachpy.stream.active_stream is not None:
1680        peachpy.stream.active_stream.add_instruction(instruction)
1681    return instruction
1682
1683
1684def SBCSLO(destination, source_x, source_y=None):
1685    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1686    if source_y is None:
1687        (destination, source_x, source_y) = (destination, destination, source_x)
1688    instruction = ArithmeticInstruction('SBCSLO', Operand(destination), Operand(source_x), Operand(source_y),
1689                                        origin=origin)
1690    if peachpy.stream.active_stream is not None:
1691        peachpy.stream.active_stream.add_instruction(instruction)
1692    return instruction
1693
1694
1695def SBCSMI(destination, source_x, source_y=None):
1696    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1697    if source_y is None:
1698        (destination, source_x, source_y) = (destination, destination, source_x)
1699    instruction = ArithmeticInstruction('SBCSMI', Operand(destination), Operand(source_x), Operand(source_y),
1700                                        origin=origin)
1701    if peachpy.stream.active_stream is not None:
1702        peachpy.stream.active_stream.add_instruction(instruction)
1703    return instruction
1704
1705
1706def SBCSPL(destination, source_x, source_y=None):
1707    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1708    if source_y is None:
1709        (destination, source_x, source_y) = (destination, destination, source_x)
1710    instruction = ArithmeticInstruction('SBCSPL', Operand(destination), Operand(source_x), Operand(source_y),
1711                                        origin=origin)
1712    if peachpy.stream.active_stream is not None:
1713        peachpy.stream.active_stream.add_instruction(instruction)
1714    return instruction
1715
1716
1717def SBCSVS(destination, source_x, source_y=None):
1718    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1719    if source_y is None:
1720        (destination, source_x, source_y) = (destination, destination, source_x)
1721    instruction = ArithmeticInstruction('SBCSVS', Operand(destination), Operand(source_x), Operand(source_y),
1722                                        origin=origin)
1723    if peachpy.stream.active_stream is not None:
1724        peachpy.stream.active_stream.add_instruction(instruction)
1725    return instruction
1726
1727
1728def SBCSVC(destination, source_x, source_y=None):
1729    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1730    if source_y is None:
1731        (destination, source_x, source_y) = (destination, destination, source_x)
1732    instruction = ArithmeticInstruction('SBCSVC', Operand(destination), Operand(source_x), Operand(source_y),
1733                                        origin=origin)
1734    if peachpy.stream.active_stream is not None:
1735        peachpy.stream.active_stream.add_instruction(instruction)
1736    return instruction
1737
1738
1739def SBCSHI(destination, source_x, source_y=None):
1740    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1741    if source_y is None:
1742        (destination, source_x, source_y) = (destination, destination, source_x)
1743    instruction = ArithmeticInstruction('SBCSHI', Operand(destination), Operand(source_x), Operand(source_y),
1744                                        origin=origin)
1745    if peachpy.stream.active_stream is not None:
1746        peachpy.stream.active_stream.add_instruction(instruction)
1747    return instruction
1748
1749
1750def SBCSLS(destination, source_x, source_y=None):
1751    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1752    if source_y is None:
1753        (destination, source_x, source_y) = (destination, destination, source_x)
1754    instruction = ArithmeticInstruction('SBCSLS', Operand(destination), Operand(source_x), Operand(source_y),
1755                                        origin=origin)
1756    if peachpy.stream.active_stream is not None:
1757        peachpy.stream.active_stream.add_instruction(instruction)
1758    return instruction
1759
1760
1761def SBCSGE(destination, source_x, source_y=None):
1762    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1763    if source_y is None:
1764        (destination, source_x, source_y) = (destination, destination, source_x)
1765    instruction = ArithmeticInstruction('SBCSGE', Operand(destination), Operand(source_x), Operand(source_y),
1766                                        origin=origin)
1767    if peachpy.stream.active_stream is not None:
1768        peachpy.stream.active_stream.add_instruction(instruction)
1769    return instruction
1770
1771
1772def SBCSLT(destination, source_x, source_y=None):
1773    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1774    if source_y is None:
1775        (destination, source_x, source_y) = (destination, destination, source_x)
1776    instruction = ArithmeticInstruction('SBCSLT', Operand(destination), Operand(source_x), Operand(source_y),
1777                                        origin=origin)
1778    if peachpy.stream.active_stream is not None:
1779        peachpy.stream.active_stream.add_instruction(instruction)
1780    return instruction
1781
1782
1783def SBCSGT(destination, source_x, source_y=None):
1784    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1785    if source_y is None:
1786        (destination, source_x, source_y) = (destination, destination, source_x)
1787    instruction = ArithmeticInstruction('SBCSGT', Operand(destination), Operand(source_x), Operand(source_y),
1788                                        origin=origin)
1789    if peachpy.stream.active_stream is not None:
1790        peachpy.stream.active_stream.add_instruction(instruction)
1791    return instruction
1792
1793
1794def SBCSLE(destination, source_x, source_y=None):
1795    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1796    if source_y is None:
1797        (destination, source_x, source_y) = (destination, destination, source_x)
1798    instruction = ArithmeticInstruction('SBCSLE', Operand(destination), Operand(source_x), Operand(source_y),
1799                                        origin=origin)
1800    if peachpy.stream.active_stream is not None:
1801        peachpy.stream.active_stream.add_instruction(instruction)
1802    return instruction
1803
1804
1805def RSB(destination, source_x, source_y=None):
1806    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1807    if source_y is None:
1808        (destination, source_x, source_y) = (destination, destination, source_x)
1809    instruction = ArithmeticInstruction('RSB', Operand(destination), Operand(source_x), Operand(source_y),
1810                                        origin=origin)
1811    if peachpy.stream.active_stream is not None:
1812        peachpy.stream.active_stream.add_instruction(instruction)
1813    return instruction
1814
1815
1816def RSBEQ(destination, source_x, source_y=None):
1817    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1818    if source_y is None:
1819        (destination, source_x, source_y) = (destination, destination, source_x)
1820    instruction = ArithmeticInstruction('RSBEQ', Operand(destination), Operand(source_x), Operand(source_y),
1821                                        origin=origin)
1822    if peachpy.stream.active_stream is not None:
1823        peachpy.stream.active_stream.add_instruction(instruction)
1824    return instruction
1825
1826
1827def RSBNE(destination, source_x, source_y=None):
1828    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1829    if source_y is None:
1830        (destination, source_x, source_y) = (destination, destination, source_x)
1831    instruction = ArithmeticInstruction('RSBNE', Operand(destination), Operand(source_x), Operand(source_y),
1832                                        origin=origin)
1833    if peachpy.stream.active_stream is not None:
1834        peachpy.stream.active_stream.add_instruction(instruction)
1835    return instruction
1836
1837
1838def RSBCS(destination, source_x, source_y=None):
1839    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1840    if source_y is None:
1841        (destination, source_x, source_y) = (destination, destination, source_x)
1842    instruction = ArithmeticInstruction('RSBCS', Operand(destination), Operand(source_x), Operand(source_y),
1843                                        origin=origin)
1844    if peachpy.stream.active_stream is not None:
1845        peachpy.stream.active_stream.add_instruction(instruction)
1846    return instruction
1847
1848
1849def RSBHS(destination, source_x, source_y=None):
1850    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1851    if source_y is None:
1852        (destination, source_x, source_y) = (destination, destination, source_x)
1853    instruction = ArithmeticInstruction('RSBHS', Operand(destination), Operand(source_x), Operand(source_y),
1854                                        origin=origin)
1855    if peachpy.stream.active_stream is not None:
1856        peachpy.stream.active_stream.add_instruction(instruction)
1857    return instruction
1858
1859
1860def RSBCC(destination, source_x, source_y=None):
1861    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1862    if source_y is None:
1863        (destination, source_x, source_y) = (destination, destination, source_x)
1864    instruction = ArithmeticInstruction('RSBCC', Operand(destination), Operand(source_x), Operand(source_y),
1865                                        origin=origin)
1866    if peachpy.stream.active_stream is not None:
1867        peachpy.stream.active_stream.add_instruction(instruction)
1868    return instruction
1869
1870
1871def RSBLO(destination, source_x, source_y=None):
1872    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1873    if source_y is None:
1874        (destination, source_x, source_y) = (destination, destination, source_x)
1875    instruction = ArithmeticInstruction('RSBLO', Operand(destination), Operand(source_x), Operand(source_y),
1876                                        origin=origin)
1877    if peachpy.stream.active_stream is not None:
1878        peachpy.stream.active_stream.add_instruction(instruction)
1879    return instruction
1880
1881
1882def RSBMI(destination, source_x, source_y=None):
1883    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1884    if source_y is None:
1885        (destination, source_x, source_y) = (destination, destination, source_x)
1886    instruction = ArithmeticInstruction('RSBMI', Operand(destination), Operand(source_x), Operand(source_y),
1887                                        origin=origin)
1888    if peachpy.stream.active_stream is not None:
1889        peachpy.stream.active_stream.add_instruction(instruction)
1890    return instruction
1891
1892
1893def RSBPL(destination, source_x, source_y=None):
1894    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1895    if source_y is None:
1896        (destination, source_x, source_y) = (destination, destination, source_x)
1897    instruction = ArithmeticInstruction('RSBPL', Operand(destination), Operand(source_x), Operand(source_y),
1898                                        origin=origin)
1899    if peachpy.stream.active_stream is not None:
1900        peachpy.stream.active_stream.add_instruction(instruction)
1901    return instruction
1902
1903
1904def RSBVS(destination, source_x, source_y=None):
1905    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1906    if source_y is None:
1907        (destination, source_x, source_y) = (destination, destination, source_x)
1908    instruction = ArithmeticInstruction('RSBVS', Operand(destination), Operand(source_x), Operand(source_y),
1909                                        origin=origin)
1910    if peachpy.stream.active_stream is not None:
1911        peachpy.stream.active_stream.add_instruction(instruction)
1912    return instruction
1913
1914
1915def RSBVC(destination, source_x, source_y=None):
1916    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1917    if source_y is None:
1918        (destination, source_x, source_y) = (destination, destination, source_x)
1919    instruction = ArithmeticInstruction('RSBVC', Operand(destination), Operand(source_x), Operand(source_y),
1920                                        origin=origin)
1921    if peachpy.stream.active_stream is not None:
1922        peachpy.stream.active_stream.add_instruction(instruction)
1923    return instruction
1924
1925
1926def RSBHI(destination, source_x, source_y=None):
1927    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1928    if source_y is None:
1929        (destination, source_x, source_y) = (destination, destination, source_x)
1930    instruction = ArithmeticInstruction('RSBHI', Operand(destination), Operand(source_x), Operand(source_y),
1931                                        origin=origin)
1932    if peachpy.stream.active_stream is not None:
1933        peachpy.stream.active_stream.add_instruction(instruction)
1934    return instruction
1935
1936
1937def RSBLS(destination, source_x, source_y=None):
1938    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1939    if source_y is None:
1940        (destination, source_x, source_y) = (destination, destination, source_x)
1941    instruction = ArithmeticInstruction('RSBLS', Operand(destination), Operand(source_x), Operand(source_y),
1942                                        origin=origin)
1943    if peachpy.stream.active_stream is not None:
1944        peachpy.stream.active_stream.add_instruction(instruction)
1945    return instruction
1946
1947
1948def RSBGE(destination, source_x, source_y=None):
1949    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1950    if source_y is None:
1951        (destination, source_x, source_y) = (destination, destination, source_x)
1952    instruction = ArithmeticInstruction('RSBGE', Operand(destination), Operand(source_x), Operand(source_y),
1953                                        origin=origin)
1954    if peachpy.stream.active_stream is not None:
1955        peachpy.stream.active_stream.add_instruction(instruction)
1956    return instruction
1957
1958
1959def RSBLT(destination, source_x, source_y=None):
1960    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1961    if source_y is None:
1962        (destination, source_x, source_y) = (destination, destination, source_x)
1963    instruction = ArithmeticInstruction('RSBLT', Operand(destination), Operand(source_x), Operand(source_y),
1964                                        origin=origin)
1965    if peachpy.stream.active_stream is not None:
1966        peachpy.stream.active_stream.add_instruction(instruction)
1967    return instruction
1968
1969
1970def RSBGT(destination, source_x, source_y=None):
1971    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1972    if source_y is None:
1973        (destination, source_x, source_y) = (destination, destination, source_x)
1974    instruction = ArithmeticInstruction('RSBGT', Operand(destination), Operand(source_x), Operand(source_y),
1975                                        origin=origin)
1976    if peachpy.stream.active_stream is not None:
1977        peachpy.stream.active_stream.add_instruction(instruction)
1978    return instruction
1979
1980
1981def RSBLE(destination, source_x, source_y=None):
1982    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1983    if source_y is None:
1984        (destination, source_x, source_y) = (destination, destination, source_x)
1985    instruction = ArithmeticInstruction('RSBLE', Operand(destination), Operand(source_x), Operand(source_y),
1986                                        origin=origin)
1987    if peachpy.stream.active_stream is not None:
1988        peachpy.stream.active_stream.add_instruction(instruction)
1989    return instruction
1990
1991
1992def RSBS(destination, source_x, source_y=None):
1993    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
1994    if source_y is None:
1995        (destination, source_x, source_y) = (destination, destination, source_x)
1996    instruction = ArithmeticInstruction('RSBS', Operand(destination), Operand(source_x), Operand(source_y),
1997                                        origin=origin)
1998    if peachpy.stream.active_stream is not None:
1999        peachpy.stream.active_stream.add_instruction(instruction)
2000    return instruction
2001
2002
2003def RSBSEQ(destination, source_x, source_y=None):
2004    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2005    if source_y is None:
2006        (destination, source_x, source_y) = (destination, destination, source_x)
2007    instruction = ArithmeticInstruction('RSBSEQ', Operand(destination), Operand(source_x), Operand(source_y),
2008                                        origin=origin)
2009    if peachpy.stream.active_stream is not None:
2010        peachpy.stream.active_stream.add_instruction(instruction)
2011    return instruction
2012
2013
2014def RSBSNE(destination, source_x, source_y=None):
2015    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2016    if source_y is None:
2017        (destination, source_x, source_y) = (destination, destination, source_x)
2018    instruction = ArithmeticInstruction('RSBSNE', Operand(destination), Operand(source_x), Operand(source_y),
2019                                        origin=origin)
2020    if peachpy.stream.active_stream is not None:
2021        peachpy.stream.active_stream.add_instruction(instruction)
2022    return instruction
2023
2024
2025def RSBSCS(destination, source_x, source_y=None):
2026    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2027    if source_y is None:
2028        (destination, source_x, source_y) = (destination, destination, source_x)
2029    instruction = ArithmeticInstruction('RSBSCS', Operand(destination), Operand(source_x), Operand(source_y),
2030                                        origin=origin)
2031    if peachpy.stream.active_stream is not None:
2032        peachpy.stream.active_stream.add_instruction(instruction)
2033    return instruction
2034
2035
2036def RSBSHS(destination, source_x, source_y=None):
2037    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2038    if source_y is None:
2039        (destination, source_x, source_y) = (destination, destination, source_x)
2040    instruction = ArithmeticInstruction('RSBSHS', Operand(destination), Operand(source_x), Operand(source_y),
2041                                        origin=origin)
2042    if peachpy.stream.active_stream is not None:
2043        peachpy.stream.active_stream.add_instruction(instruction)
2044    return instruction
2045
2046
2047def RSBSCC(destination, source_x, source_y=None):
2048    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2049    if source_y is None:
2050        (destination, source_x, source_y) = (destination, destination, source_x)
2051    instruction = ArithmeticInstruction('RSBSCC', Operand(destination), Operand(source_x), Operand(source_y),
2052                                        origin=origin)
2053    if peachpy.stream.active_stream is not None:
2054        peachpy.stream.active_stream.add_instruction(instruction)
2055    return instruction
2056
2057
2058def RSBSLO(destination, source_x, source_y=None):
2059    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2060    if source_y is None:
2061        (destination, source_x, source_y) = (destination, destination, source_x)
2062    instruction = ArithmeticInstruction('RSBSLO', Operand(destination), Operand(source_x), Operand(source_y),
2063                                        origin=origin)
2064    if peachpy.stream.active_stream is not None:
2065        peachpy.stream.active_stream.add_instruction(instruction)
2066    return instruction
2067
2068
2069def RSBSMI(destination, source_x, source_y=None):
2070    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2071    if source_y is None:
2072        (destination, source_x, source_y) = (destination, destination, source_x)
2073    instruction = ArithmeticInstruction('RSBSMI', Operand(destination), Operand(source_x), Operand(source_y),
2074                                        origin=origin)
2075    if peachpy.stream.active_stream is not None:
2076        peachpy.stream.active_stream.add_instruction(instruction)
2077    return instruction
2078
2079
2080def RSBSPL(destination, source_x, source_y=None):
2081    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2082    if source_y is None:
2083        (destination, source_x, source_y) = (destination, destination, source_x)
2084    instruction = ArithmeticInstruction('RSBSPL', Operand(destination), Operand(source_x), Operand(source_y),
2085                                        origin=origin)
2086    if peachpy.stream.active_stream is not None:
2087        peachpy.stream.active_stream.add_instruction(instruction)
2088    return instruction
2089
2090
2091def RSBSVS(destination, source_x, source_y=None):
2092    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2093    if source_y is None:
2094        (destination, source_x, source_y) = (destination, destination, source_x)
2095    instruction = ArithmeticInstruction('RSBSVS', Operand(destination), Operand(source_x), Operand(source_y),
2096                                        origin=origin)
2097    if peachpy.stream.active_stream is not None:
2098        peachpy.stream.active_stream.add_instruction(instruction)
2099    return instruction
2100
2101
2102def RSBSVC(destination, source_x, source_y=None):
2103    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2104    if source_y is None:
2105        (destination, source_x, source_y) = (destination, destination, source_x)
2106    instruction = ArithmeticInstruction('RSBSVC', Operand(destination), Operand(source_x), Operand(source_y),
2107                                        origin=origin)
2108    if peachpy.stream.active_stream is not None:
2109        peachpy.stream.active_stream.add_instruction(instruction)
2110    return instruction
2111
2112
2113def RSBSHI(destination, source_x, source_y=None):
2114    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2115    if source_y is None:
2116        (destination, source_x, source_y) = (destination, destination, source_x)
2117    instruction = ArithmeticInstruction('RSBSHI', Operand(destination), Operand(source_x), Operand(source_y),
2118                                        origin=origin)
2119    if peachpy.stream.active_stream is not None:
2120        peachpy.stream.active_stream.add_instruction(instruction)
2121    return instruction
2122
2123
2124def RSBSLS(destination, source_x, source_y=None):
2125    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2126    if source_y is None:
2127        (destination, source_x, source_y) = (destination, destination, source_x)
2128    instruction = ArithmeticInstruction('RSBSLS', Operand(destination), Operand(source_x), Operand(source_y),
2129                                        origin=origin)
2130    if peachpy.stream.active_stream is not None:
2131        peachpy.stream.active_stream.add_instruction(instruction)
2132    return instruction
2133
2134
2135def RSBSGE(destination, source_x, source_y=None):
2136    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2137    if source_y is None:
2138        (destination, source_x, source_y) = (destination, destination, source_x)
2139    instruction = ArithmeticInstruction('RSBSGE', Operand(destination), Operand(source_x), Operand(source_y),
2140                                        origin=origin)
2141    if peachpy.stream.active_stream is not None:
2142        peachpy.stream.active_stream.add_instruction(instruction)
2143    return instruction
2144
2145
2146def RSBSLT(destination, source_x, source_y=None):
2147    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2148    if source_y is None:
2149        (destination, source_x, source_y) = (destination, destination, source_x)
2150    instruction = ArithmeticInstruction('RSBSLT', Operand(destination), Operand(source_x), Operand(source_y),
2151                                        origin=origin)
2152    if peachpy.stream.active_stream is not None:
2153        peachpy.stream.active_stream.add_instruction(instruction)
2154    return instruction
2155
2156
2157def RSBSGT(destination, source_x, source_y=None):
2158    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2159    if source_y is None:
2160        (destination, source_x, source_y) = (destination, destination, source_x)
2161    instruction = ArithmeticInstruction('RSBSGT', Operand(destination), Operand(source_x), Operand(source_y),
2162                                        origin=origin)
2163    if peachpy.stream.active_stream is not None:
2164        peachpy.stream.active_stream.add_instruction(instruction)
2165    return instruction
2166
2167
2168def RSBSLE(destination, source_x, source_y=None):
2169    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2170    if source_y is None:
2171        (destination, source_x, source_y) = (destination, destination, source_x)
2172    instruction = ArithmeticInstruction('RSBSLE', Operand(destination), Operand(source_x), Operand(source_y),
2173                                        origin=origin)
2174    if peachpy.stream.active_stream is not None:
2175        peachpy.stream.active_stream.add_instruction(instruction)
2176    return instruction
2177
2178
2179def RSC(destination, source_x, source_y=None):
2180    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2181    if source_y is None:
2182        (destination, source_x, source_y) = (destination, destination, source_x)
2183    instruction = ArithmeticInstruction('RSC', Operand(destination), Operand(source_x), Operand(source_y),
2184                                        origin=origin)
2185    if peachpy.stream.active_stream is not None:
2186        peachpy.stream.active_stream.add_instruction(instruction)
2187    return instruction
2188
2189
2190def RSCEQ(destination, source_x, source_y=None):
2191    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2192    if source_y is None:
2193        (destination, source_x, source_y) = (destination, destination, source_x)
2194    instruction = ArithmeticInstruction('RSCEQ', Operand(destination), Operand(source_x), Operand(source_y),
2195                                        origin=origin)
2196    if peachpy.stream.active_stream is not None:
2197        peachpy.stream.active_stream.add_instruction(instruction)
2198    return instruction
2199
2200
2201def RSCNE(destination, source_x, source_y=None):
2202    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2203    if source_y is None:
2204        (destination, source_x, source_y) = (destination, destination, source_x)
2205    instruction = ArithmeticInstruction('RSCNE', Operand(destination), Operand(source_x), Operand(source_y),
2206                                        origin=origin)
2207    if peachpy.stream.active_stream is not None:
2208        peachpy.stream.active_stream.add_instruction(instruction)
2209    return instruction
2210
2211
2212def RSCCS(destination, source_x, source_y=None):
2213    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2214    if source_y is None:
2215        (destination, source_x, source_y) = (destination, destination, source_x)
2216    instruction = ArithmeticInstruction('RSCCS', Operand(destination), Operand(source_x), Operand(source_y),
2217                                        origin=origin)
2218    if peachpy.stream.active_stream is not None:
2219        peachpy.stream.active_stream.add_instruction(instruction)
2220    return instruction
2221
2222
2223def RSCHS(destination, source_x, source_y=None):
2224    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2225    if source_y is None:
2226        (destination, source_x, source_y) = (destination, destination, source_x)
2227    instruction = ArithmeticInstruction('RSCHS', Operand(destination), Operand(source_x), Operand(source_y),
2228                                        origin=origin)
2229    if peachpy.stream.active_stream is not None:
2230        peachpy.stream.active_stream.add_instruction(instruction)
2231    return instruction
2232
2233
2234def RSCCC(destination, source_x, source_y=None):
2235    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2236    if source_y is None:
2237        (destination, source_x, source_y) = (destination, destination, source_x)
2238    instruction = ArithmeticInstruction('RSCCC', Operand(destination), Operand(source_x), Operand(source_y),
2239                                        origin=origin)
2240    if peachpy.stream.active_stream is not None:
2241        peachpy.stream.active_stream.add_instruction(instruction)
2242    return instruction
2243
2244
2245def RSCLO(destination, source_x, source_y=None):
2246    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2247    if source_y is None:
2248        (destination, source_x, source_y) = (destination, destination, source_x)
2249    instruction = ArithmeticInstruction('RSCLO', Operand(destination), Operand(source_x), Operand(source_y),
2250                                        origin=origin)
2251    if peachpy.stream.active_stream is not None:
2252        peachpy.stream.active_stream.add_instruction(instruction)
2253    return instruction
2254
2255
2256def RSCMI(destination, source_x, source_y=None):
2257    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2258    if source_y is None:
2259        (destination, source_x, source_y) = (destination, destination, source_x)
2260    instruction = ArithmeticInstruction('RSCMI', Operand(destination), Operand(source_x), Operand(source_y),
2261                                        origin=origin)
2262    if peachpy.stream.active_stream is not None:
2263        peachpy.stream.active_stream.add_instruction(instruction)
2264    return instruction
2265
2266
2267def RSCPL(destination, source_x, source_y=None):
2268    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2269    if source_y is None:
2270        (destination, source_x, source_y) = (destination, destination, source_x)
2271    instruction = ArithmeticInstruction('RSCPL', Operand(destination), Operand(source_x), Operand(source_y),
2272                                        origin=origin)
2273    if peachpy.stream.active_stream is not None:
2274        peachpy.stream.active_stream.add_instruction(instruction)
2275    return instruction
2276
2277
2278def RSCVS(destination, source_x, source_y=None):
2279    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2280    if source_y is None:
2281        (destination, source_x, source_y) = (destination, destination, source_x)
2282    instruction = ArithmeticInstruction('RSCVS', Operand(destination), Operand(source_x), Operand(source_y),
2283                                        origin=origin)
2284    if peachpy.stream.active_stream is not None:
2285        peachpy.stream.active_stream.add_instruction(instruction)
2286    return instruction
2287
2288
2289def RSCVC(destination, source_x, source_y=None):
2290    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2291    if source_y is None:
2292        (destination, source_x, source_y) = (destination, destination, source_x)
2293    instruction = ArithmeticInstruction('RSCVC', Operand(destination), Operand(source_x), Operand(source_y),
2294                                        origin=origin)
2295    if peachpy.stream.active_stream is not None:
2296        peachpy.stream.active_stream.add_instruction(instruction)
2297    return instruction
2298
2299
2300def RSCHI(destination, source_x, source_y=None):
2301    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2302    if source_y is None:
2303        (destination, source_x, source_y) = (destination, destination, source_x)
2304    instruction = ArithmeticInstruction('RSCHI', Operand(destination), Operand(source_x), Operand(source_y),
2305                                        origin=origin)
2306    if peachpy.stream.active_stream is not None:
2307        peachpy.stream.active_stream.add_instruction(instruction)
2308    return instruction
2309
2310
2311def RSCLS(destination, source_x, source_y=None):
2312    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2313    if source_y is None:
2314        (destination, source_x, source_y) = (destination, destination, source_x)
2315    instruction = ArithmeticInstruction('RSCLS', Operand(destination), Operand(source_x), Operand(source_y),
2316                                        origin=origin)
2317    if peachpy.stream.active_stream is not None:
2318        peachpy.stream.active_stream.add_instruction(instruction)
2319    return instruction
2320
2321
2322def RSCGE(destination, source_x, source_y=None):
2323    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2324    if source_y is None:
2325        (destination, source_x, source_y) = (destination, destination, source_x)
2326    instruction = ArithmeticInstruction('RSCGE', Operand(destination), Operand(source_x), Operand(source_y),
2327                                        origin=origin)
2328    if peachpy.stream.active_stream is not None:
2329        peachpy.stream.active_stream.add_instruction(instruction)
2330    return instruction
2331
2332
2333def RSCLT(destination, source_x, source_y=None):
2334    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2335    if source_y is None:
2336        (destination, source_x, source_y) = (destination, destination, source_x)
2337    instruction = ArithmeticInstruction('RSCLT', Operand(destination), Operand(source_x), Operand(source_y),
2338                                        origin=origin)
2339    if peachpy.stream.active_stream is not None:
2340        peachpy.stream.active_stream.add_instruction(instruction)
2341    return instruction
2342
2343
2344def RSCGT(destination, source_x, source_y=None):
2345    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2346    if source_y is None:
2347        (destination, source_x, source_y) = (destination, destination, source_x)
2348    instruction = ArithmeticInstruction('RSCGT', Operand(destination), Operand(source_x), Operand(source_y),
2349                                        origin=origin)
2350    if peachpy.stream.active_stream is not None:
2351        peachpy.stream.active_stream.add_instruction(instruction)
2352    return instruction
2353
2354
2355def RSCLE(destination, source_x, source_y=None):
2356    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2357    if source_y is None:
2358        (destination, source_x, source_y) = (destination, destination, source_x)
2359    instruction = ArithmeticInstruction('RSCLE', Operand(destination), Operand(source_x), Operand(source_y),
2360                                        origin=origin)
2361    if peachpy.stream.active_stream is not None:
2362        peachpy.stream.active_stream.add_instruction(instruction)
2363    return instruction
2364
2365
2366def RSCS(destination, source_x, source_y=None):
2367    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2368    if source_y is None:
2369        (destination, source_x, source_y) = (destination, destination, source_x)
2370    instruction = ArithmeticInstruction('RSCS', Operand(destination), Operand(source_x), Operand(source_y),
2371                                        origin=origin)
2372    if peachpy.stream.active_stream is not None:
2373        peachpy.stream.active_stream.add_instruction(instruction)
2374    return instruction
2375
2376
2377def RSCSEQ(destination, source_x, source_y=None):
2378    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2379    if source_y is None:
2380        (destination, source_x, source_y) = (destination, destination, source_x)
2381    instruction = ArithmeticInstruction('RSCSEQ', Operand(destination), Operand(source_x), Operand(source_y),
2382                                        origin=origin)
2383    if peachpy.stream.active_stream is not None:
2384        peachpy.stream.active_stream.add_instruction(instruction)
2385    return instruction
2386
2387
2388def RSCSNE(destination, source_x, source_y=None):
2389    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2390    if source_y is None:
2391        (destination, source_x, source_y) = (destination, destination, source_x)
2392    instruction = ArithmeticInstruction('RSCSNE', Operand(destination), Operand(source_x), Operand(source_y),
2393                                        origin=origin)
2394    if peachpy.stream.active_stream is not None:
2395        peachpy.stream.active_stream.add_instruction(instruction)
2396    return instruction
2397
2398
2399def RSCSCS(destination, source_x, source_y=None):
2400    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2401    if source_y is None:
2402        (destination, source_x, source_y) = (destination, destination, source_x)
2403    instruction = ArithmeticInstruction('RSCSCS', Operand(destination), Operand(source_x), Operand(source_y),
2404                                        origin=origin)
2405    if peachpy.stream.active_stream is not None:
2406        peachpy.stream.active_stream.add_instruction(instruction)
2407    return instruction
2408
2409
2410def RSCSHS(destination, source_x, source_y=None):
2411    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2412    if source_y is None:
2413        (destination, source_x, source_y) = (destination, destination, source_x)
2414    instruction = ArithmeticInstruction('RSCSHS', Operand(destination), Operand(source_x), Operand(source_y),
2415                                        origin=origin)
2416    if peachpy.stream.active_stream is not None:
2417        peachpy.stream.active_stream.add_instruction(instruction)
2418    return instruction
2419
2420
2421def RSCSCC(destination, source_x, source_y=None):
2422    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2423    if source_y is None:
2424        (destination, source_x, source_y) = (destination, destination, source_x)
2425    instruction = ArithmeticInstruction('RSCSCC', Operand(destination), Operand(source_x), Operand(source_y),
2426                                        origin=origin)
2427    if peachpy.stream.active_stream is not None:
2428        peachpy.stream.active_stream.add_instruction(instruction)
2429    return instruction
2430
2431
2432def RSCSLO(destination, source_x, source_y=None):
2433    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2434    if source_y is None:
2435        (destination, source_x, source_y) = (destination, destination, source_x)
2436    instruction = ArithmeticInstruction('RSCSLO', Operand(destination), Operand(source_x), Operand(source_y),
2437                                        origin=origin)
2438    if peachpy.stream.active_stream is not None:
2439        peachpy.stream.active_stream.add_instruction(instruction)
2440    return instruction
2441
2442
2443def RSCSMI(destination, source_x, source_y=None):
2444    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2445    if source_y is None:
2446        (destination, source_x, source_y) = (destination, destination, source_x)
2447    instruction = ArithmeticInstruction('RSCSMI', Operand(destination), Operand(source_x), Operand(source_y),
2448                                        origin=origin)
2449    if peachpy.stream.active_stream is not None:
2450        peachpy.stream.active_stream.add_instruction(instruction)
2451    return instruction
2452
2453
2454def RSCSPL(destination, source_x, source_y=None):
2455    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2456    if source_y is None:
2457        (destination, source_x, source_y) = (destination, destination, source_x)
2458    instruction = ArithmeticInstruction('RSCSPL', Operand(destination), Operand(source_x), Operand(source_y),
2459                                        origin=origin)
2460    if peachpy.stream.active_stream is not None:
2461        peachpy.stream.active_stream.add_instruction(instruction)
2462    return instruction
2463
2464
2465def RSCSVS(destination, source_x, source_y=None):
2466    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2467    if source_y is None:
2468        (destination, source_x, source_y) = (destination, destination, source_x)
2469    instruction = ArithmeticInstruction('RSCSVS', Operand(destination), Operand(source_x), Operand(source_y),
2470                                        origin=origin)
2471    if peachpy.stream.active_stream is not None:
2472        peachpy.stream.active_stream.add_instruction(instruction)
2473    return instruction
2474
2475
2476def RSCSVC(destination, source_x, source_y=None):
2477    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2478    if source_y is None:
2479        (destination, source_x, source_y) = (destination, destination, source_x)
2480    instruction = ArithmeticInstruction('RSCSVC', Operand(destination), Operand(source_x), Operand(source_y),
2481                                        origin=origin)
2482    if peachpy.stream.active_stream is not None:
2483        peachpy.stream.active_stream.add_instruction(instruction)
2484    return instruction
2485
2486
2487def RSCSHI(destination, source_x, source_y=None):
2488    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2489    if source_y is None:
2490        (destination, source_x, source_y) = (destination, destination, source_x)
2491    instruction = ArithmeticInstruction('RSCSHI', Operand(destination), Operand(source_x), Operand(source_y),
2492                                        origin=origin)
2493    if peachpy.stream.active_stream is not None:
2494        peachpy.stream.active_stream.add_instruction(instruction)
2495    return instruction
2496
2497
2498def RSCSLS(destination, source_x, source_y=None):
2499    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2500    if source_y is None:
2501        (destination, source_x, source_y) = (destination, destination, source_x)
2502    instruction = ArithmeticInstruction('RSCSLS', Operand(destination), Operand(source_x), Operand(source_y),
2503                                        origin=origin)
2504    if peachpy.stream.active_stream is not None:
2505        peachpy.stream.active_stream.add_instruction(instruction)
2506    return instruction
2507
2508
2509def RSCSGE(destination, source_x, source_y=None):
2510    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2511    if source_y is None:
2512        (destination, source_x, source_y) = (destination, destination, source_x)
2513    instruction = ArithmeticInstruction('RSCSGE', Operand(destination), Operand(source_x), Operand(source_y),
2514                                        origin=origin)
2515    if peachpy.stream.active_stream is not None:
2516        peachpy.stream.active_stream.add_instruction(instruction)
2517    return instruction
2518
2519
2520def RSCSLT(destination, source_x, source_y=None):
2521    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2522    if source_y is None:
2523        (destination, source_x, source_y) = (destination, destination, source_x)
2524    instruction = ArithmeticInstruction('RSCSLT', Operand(destination), Operand(source_x), Operand(source_y),
2525                                        origin=origin)
2526    if peachpy.stream.active_stream is not None:
2527        peachpy.stream.active_stream.add_instruction(instruction)
2528    return instruction
2529
2530
2531def RSCSGT(destination, source_x, source_y=None):
2532    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2533    if source_y is None:
2534        (destination, source_x, source_y) = (destination, destination, source_x)
2535    instruction = ArithmeticInstruction('RSCSGT', Operand(destination), Operand(source_x), Operand(source_y),
2536                                        origin=origin)
2537    if peachpy.stream.active_stream is not None:
2538        peachpy.stream.active_stream.add_instruction(instruction)
2539    return instruction
2540
2541
2542def RSCSLE(destination, source_x, source_y=None):
2543    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2544    if source_y is None:
2545        (destination, source_x, source_y) = (destination, destination, source_x)
2546    instruction = ArithmeticInstruction('RSCSLE', Operand(destination), Operand(source_x), Operand(source_y),
2547                                        origin=origin)
2548    if peachpy.stream.active_stream is not None:
2549        peachpy.stream.active_stream.add_instruction(instruction)
2550    return instruction
2551
2552
2553def AND(destination, source_x, source_y=None):
2554    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2555    if source_y is None:
2556        (destination, source_x, source_y) = (destination, destination, source_x)
2557    instruction = ArithmeticInstruction('AND', Operand(destination), Operand(source_x), Operand(source_y),
2558                                        origin=origin)
2559    if peachpy.stream.active_stream is not None:
2560        peachpy.stream.active_stream.add_instruction(instruction)
2561    return instruction
2562
2563
2564def ANDEQ(destination, source_x, source_y=None):
2565    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2566    if source_y is None:
2567        (destination, source_x, source_y) = (destination, destination, source_x)
2568    instruction = ArithmeticInstruction('ANDEQ', Operand(destination), Operand(source_x), Operand(source_y),
2569                                        origin=origin)
2570    if peachpy.stream.active_stream is not None:
2571        peachpy.stream.active_stream.add_instruction(instruction)
2572    return instruction
2573
2574
2575def ANDNE(destination, source_x, source_y=None):
2576    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2577    if source_y is None:
2578        (destination, source_x, source_y) = (destination, destination, source_x)
2579    instruction = ArithmeticInstruction('ANDNE', Operand(destination), Operand(source_x), Operand(source_y),
2580                                        origin=origin)
2581    if peachpy.stream.active_stream is not None:
2582        peachpy.stream.active_stream.add_instruction(instruction)
2583    return instruction
2584
2585
2586def ANDCS(destination, source_x, source_y=None):
2587    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2588    if source_y is None:
2589        (destination, source_x, source_y) = (destination, destination, source_x)
2590    instruction = ArithmeticInstruction('ANDCS', Operand(destination), Operand(source_x), Operand(source_y),
2591                                        origin=origin)
2592    if peachpy.stream.active_stream is not None:
2593        peachpy.stream.active_stream.add_instruction(instruction)
2594    return instruction
2595
2596
2597def ANDHS(destination, source_x, source_y=None):
2598    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2599    if source_y is None:
2600        (destination, source_x, source_y) = (destination, destination, source_x)
2601    instruction = ArithmeticInstruction('ANDHS', Operand(destination), Operand(source_x), Operand(source_y),
2602                                        origin=origin)
2603    if peachpy.stream.active_stream is not None:
2604        peachpy.stream.active_stream.add_instruction(instruction)
2605    return instruction
2606
2607
2608def ANDCC(destination, source_x, source_y=None):
2609    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2610    if source_y is None:
2611        (destination, source_x, source_y) = (destination, destination, source_x)
2612    instruction = ArithmeticInstruction('ANDCC', Operand(destination), Operand(source_x), Operand(source_y),
2613                                        origin=origin)
2614    if peachpy.stream.active_stream is not None:
2615        peachpy.stream.active_stream.add_instruction(instruction)
2616    return instruction
2617
2618
2619def ANDLO(destination, source_x, source_y=None):
2620    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2621    if source_y is None:
2622        (destination, source_x, source_y) = (destination, destination, source_x)
2623    instruction = ArithmeticInstruction('ANDLO', Operand(destination), Operand(source_x), Operand(source_y),
2624                                        origin=origin)
2625    if peachpy.stream.active_stream is not None:
2626        peachpy.stream.active_stream.add_instruction(instruction)
2627    return instruction
2628
2629
2630def ANDMI(destination, source_x, source_y=None):
2631    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2632    if source_y is None:
2633        (destination, source_x, source_y) = (destination, destination, source_x)
2634    instruction = ArithmeticInstruction('ANDMI', Operand(destination), Operand(source_x), Operand(source_y),
2635                                        origin=origin)
2636    if peachpy.stream.active_stream is not None:
2637        peachpy.stream.active_stream.add_instruction(instruction)
2638    return instruction
2639
2640
2641def ANDPL(destination, source_x, source_y=None):
2642    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2643    if source_y is None:
2644        (destination, source_x, source_y) = (destination, destination, source_x)
2645    instruction = ArithmeticInstruction('ANDPL', Operand(destination), Operand(source_x), Operand(source_y),
2646                                        origin=origin)
2647    if peachpy.stream.active_stream is not None:
2648        peachpy.stream.active_stream.add_instruction(instruction)
2649    return instruction
2650
2651
2652def ANDVS(destination, source_x, source_y=None):
2653    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2654    if source_y is None:
2655        (destination, source_x, source_y) = (destination, destination, source_x)
2656    instruction = ArithmeticInstruction('ANDVS', Operand(destination), Operand(source_x), Operand(source_y),
2657                                        origin=origin)
2658    if peachpy.stream.active_stream is not None:
2659        peachpy.stream.active_stream.add_instruction(instruction)
2660    return instruction
2661
2662
2663def ANDVC(destination, source_x, source_y=None):
2664    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2665    if source_y is None:
2666        (destination, source_x, source_y) = (destination, destination, source_x)
2667    instruction = ArithmeticInstruction('ANDVC', Operand(destination), Operand(source_x), Operand(source_y),
2668                                        origin=origin)
2669    if peachpy.stream.active_stream is not None:
2670        peachpy.stream.active_stream.add_instruction(instruction)
2671    return instruction
2672
2673
2674def ANDHI(destination, source_x, source_y=None):
2675    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2676    if source_y is None:
2677        (destination, source_x, source_y) = (destination, destination, source_x)
2678    instruction = ArithmeticInstruction('ANDHI', Operand(destination), Operand(source_x), Operand(source_y),
2679                                        origin=origin)
2680    if peachpy.stream.active_stream is not None:
2681        peachpy.stream.active_stream.add_instruction(instruction)
2682    return instruction
2683
2684
2685def ANDLS(destination, source_x, source_y=None):
2686    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2687    if source_y is None:
2688        (destination, source_x, source_y) = (destination, destination, source_x)
2689    instruction = ArithmeticInstruction('ANDLS', Operand(destination), Operand(source_x), Operand(source_y),
2690                                        origin=origin)
2691    if peachpy.stream.active_stream is not None:
2692        peachpy.stream.active_stream.add_instruction(instruction)
2693    return instruction
2694
2695
2696def ANDGE(destination, source_x, source_y=None):
2697    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2698    if source_y is None:
2699        (destination, source_x, source_y) = (destination, destination, source_x)
2700    instruction = ArithmeticInstruction('ANDGE', Operand(destination), Operand(source_x), Operand(source_y),
2701                                        origin=origin)
2702    if peachpy.stream.active_stream is not None:
2703        peachpy.stream.active_stream.add_instruction(instruction)
2704    return instruction
2705
2706
2707def ANDLT(destination, source_x, source_y=None):
2708    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2709    if source_y is None:
2710        (destination, source_x, source_y) = (destination, destination, source_x)
2711    instruction = ArithmeticInstruction('ANDLT', Operand(destination), Operand(source_x), Operand(source_y),
2712                                        origin=origin)
2713    if peachpy.stream.active_stream is not None:
2714        peachpy.stream.active_stream.add_instruction(instruction)
2715    return instruction
2716
2717
2718def ANDGT(destination, source_x, source_y=None):
2719    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2720    if source_y is None:
2721        (destination, source_x, source_y) = (destination, destination, source_x)
2722    instruction = ArithmeticInstruction('ANDGT', Operand(destination), Operand(source_x), Operand(source_y),
2723                                        origin=origin)
2724    if peachpy.stream.active_stream is not None:
2725        peachpy.stream.active_stream.add_instruction(instruction)
2726    return instruction
2727
2728
2729def ANDLE(destination, source_x, source_y=None):
2730    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2731    if source_y is None:
2732        (destination, source_x, source_y) = (destination, destination, source_x)
2733    instruction = ArithmeticInstruction('ANDLE', Operand(destination), Operand(source_x), Operand(source_y),
2734                                        origin=origin)
2735    if peachpy.stream.active_stream is not None:
2736        peachpy.stream.active_stream.add_instruction(instruction)
2737    return instruction
2738
2739
2740def ANDS(destination, source_x, source_y=None):
2741    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2742    if source_y is None:
2743        (destination, source_x, source_y) = (destination, destination, source_x)
2744    instruction = ArithmeticInstruction('ANDS', Operand(destination), Operand(source_x), Operand(source_y),
2745                                        origin=origin)
2746    if peachpy.stream.active_stream is not None:
2747        peachpy.stream.active_stream.add_instruction(instruction)
2748    return instruction
2749
2750
2751def ANDSEQ(destination, source_x, source_y=None):
2752    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2753    if source_y is None:
2754        (destination, source_x, source_y) = (destination, destination, source_x)
2755    instruction = ArithmeticInstruction('ANDSEQ', Operand(destination), Operand(source_x), Operand(source_y),
2756                                        origin=origin)
2757    if peachpy.stream.active_stream is not None:
2758        peachpy.stream.active_stream.add_instruction(instruction)
2759    return instruction
2760
2761
2762def ANDSNE(destination, source_x, source_y=None):
2763    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2764    if source_y is None:
2765        (destination, source_x, source_y) = (destination, destination, source_x)
2766    instruction = ArithmeticInstruction('ANDSNE', Operand(destination), Operand(source_x), Operand(source_y),
2767                                        origin=origin)
2768    if peachpy.stream.active_stream is not None:
2769        peachpy.stream.active_stream.add_instruction(instruction)
2770    return instruction
2771
2772
2773def ANDSCS(destination, source_x, source_y=None):
2774    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2775    if source_y is None:
2776        (destination, source_x, source_y) = (destination, destination, source_x)
2777    instruction = ArithmeticInstruction('ANDSCS', Operand(destination), Operand(source_x), Operand(source_y),
2778                                        origin=origin)
2779    if peachpy.stream.active_stream is not None:
2780        peachpy.stream.active_stream.add_instruction(instruction)
2781    return instruction
2782
2783
2784def ANDSHS(destination, source_x, source_y=None):
2785    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2786    if source_y is None:
2787        (destination, source_x, source_y) = (destination, destination, source_x)
2788    instruction = ArithmeticInstruction('ANDSHS', Operand(destination), Operand(source_x), Operand(source_y),
2789                                        origin=origin)
2790    if peachpy.stream.active_stream is not None:
2791        peachpy.stream.active_stream.add_instruction(instruction)
2792    return instruction
2793
2794
2795def ANDSCC(destination, source_x, source_y=None):
2796    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2797    if source_y is None:
2798        (destination, source_x, source_y) = (destination, destination, source_x)
2799    instruction = ArithmeticInstruction('ANDSCC', Operand(destination), Operand(source_x), Operand(source_y),
2800                                        origin=origin)
2801    if peachpy.stream.active_stream is not None:
2802        peachpy.stream.active_stream.add_instruction(instruction)
2803    return instruction
2804
2805
2806def ANDSLO(destination, source_x, source_y=None):
2807    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2808    if source_y is None:
2809        (destination, source_x, source_y) = (destination, destination, source_x)
2810    instruction = ArithmeticInstruction('ANDSLO', Operand(destination), Operand(source_x), Operand(source_y),
2811                                        origin=origin)
2812    if peachpy.stream.active_stream is not None:
2813        peachpy.stream.active_stream.add_instruction(instruction)
2814    return instruction
2815
2816
2817def ANDSMI(destination, source_x, source_y=None):
2818    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2819    if source_y is None:
2820        (destination, source_x, source_y) = (destination, destination, source_x)
2821    instruction = ArithmeticInstruction('ANDSMI', Operand(destination), Operand(source_x), Operand(source_y),
2822                                        origin=origin)
2823    if peachpy.stream.active_stream is not None:
2824        peachpy.stream.active_stream.add_instruction(instruction)
2825    return instruction
2826
2827
2828def ANDSPL(destination, source_x, source_y=None):
2829    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2830    if source_y is None:
2831        (destination, source_x, source_y) = (destination, destination, source_x)
2832    instruction = ArithmeticInstruction('ANDSPL', Operand(destination), Operand(source_x), Operand(source_y),
2833                                        origin=origin)
2834    if peachpy.stream.active_stream is not None:
2835        peachpy.stream.active_stream.add_instruction(instruction)
2836    return instruction
2837
2838
2839def ANDSVS(destination, source_x, source_y=None):
2840    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2841    if source_y is None:
2842        (destination, source_x, source_y) = (destination, destination, source_x)
2843    instruction = ArithmeticInstruction('ANDSVS', Operand(destination), Operand(source_x), Operand(source_y),
2844                                        origin=origin)
2845    if peachpy.stream.active_stream is not None:
2846        peachpy.stream.active_stream.add_instruction(instruction)
2847    return instruction
2848
2849
2850def ANDSVC(destination, source_x, source_y=None):
2851    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2852    if source_y is None:
2853        (destination, source_x, source_y) = (destination, destination, source_x)
2854    instruction = ArithmeticInstruction('ANDSVC', Operand(destination), Operand(source_x), Operand(source_y),
2855                                        origin=origin)
2856    if peachpy.stream.active_stream is not None:
2857        peachpy.stream.active_stream.add_instruction(instruction)
2858    return instruction
2859
2860
2861def ANDSHI(destination, source_x, source_y=None):
2862    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2863    if source_y is None:
2864        (destination, source_x, source_y) = (destination, destination, source_x)
2865    instruction = ArithmeticInstruction('ANDSHI', Operand(destination), Operand(source_x), Operand(source_y),
2866                                        origin=origin)
2867    if peachpy.stream.active_stream is not None:
2868        peachpy.stream.active_stream.add_instruction(instruction)
2869    return instruction
2870
2871
2872def ANDSLS(destination, source_x, source_y=None):
2873    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2874    if source_y is None:
2875        (destination, source_x, source_y) = (destination, destination, source_x)
2876    instruction = ArithmeticInstruction('ANDSLS', Operand(destination), Operand(source_x), Operand(source_y),
2877                                        origin=origin)
2878    if peachpy.stream.active_stream is not None:
2879        peachpy.stream.active_stream.add_instruction(instruction)
2880    return instruction
2881
2882
2883def ANDSGE(destination, source_x, source_y=None):
2884    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2885    if source_y is None:
2886        (destination, source_x, source_y) = (destination, destination, source_x)
2887    instruction = ArithmeticInstruction('ANDSGE', Operand(destination), Operand(source_x), Operand(source_y),
2888                                        origin=origin)
2889    if peachpy.stream.active_stream is not None:
2890        peachpy.stream.active_stream.add_instruction(instruction)
2891    return instruction
2892
2893
2894def ANDSLT(destination, source_x, source_y=None):
2895    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2896    if source_y is None:
2897        (destination, source_x, source_y) = (destination, destination, source_x)
2898    instruction = ArithmeticInstruction('ANDSLT', Operand(destination), Operand(source_x), Operand(source_y),
2899                                        origin=origin)
2900    if peachpy.stream.active_stream is not None:
2901        peachpy.stream.active_stream.add_instruction(instruction)
2902    return instruction
2903
2904
2905def ANDSGT(destination, source_x, source_y=None):
2906    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2907    if source_y is None:
2908        (destination, source_x, source_y) = (destination, destination, source_x)
2909    instruction = ArithmeticInstruction('ANDSGT', Operand(destination), Operand(source_x), Operand(source_y),
2910                                        origin=origin)
2911    if peachpy.stream.active_stream is not None:
2912        peachpy.stream.active_stream.add_instruction(instruction)
2913    return instruction
2914
2915
2916def ANDSLE(destination, source_x, source_y=None):
2917    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2918    if source_y is None:
2919        (destination, source_x, source_y) = (destination, destination, source_x)
2920    instruction = ArithmeticInstruction('ANDSLE', Operand(destination), Operand(source_x), Operand(source_y),
2921                                        origin=origin)
2922    if peachpy.stream.active_stream is not None:
2923        peachpy.stream.active_stream.add_instruction(instruction)
2924    return instruction
2925
2926
2927def BIC(destination, source_x, source_y=None):
2928    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2929    if source_y is None:
2930        (destination, source_x, source_y) = (destination, destination, source_x)
2931    instruction = ArithmeticInstruction('BIC', Operand(destination), Operand(source_x), Operand(source_y),
2932                                        origin=origin)
2933    if peachpy.stream.active_stream is not None:
2934        peachpy.stream.active_stream.add_instruction(instruction)
2935    return instruction
2936
2937
2938def BICEQ(destination, source_x, source_y=None):
2939    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2940    if source_y is None:
2941        (destination, source_x, source_y) = (destination, destination, source_x)
2942    instruction = ArithmeticInstruction('BICEQ', Operand(destination), Operand(source_x), Operand(source_y),
2943                                        origin=origin)
2944    if peachpy.stream.active_stream is not None:
2945        peachpy.stream.active_stream.add_instruction(instruction)
2946    return instruction
2947
2948
2949def BICNE(destination, source_x, source_y=None):
2950    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2951    if source_y is None:
2952        (destination, source_x, source_y) = (destination, destination, source_x)
2953    instruction = ArithmeticInstruction('BICNE', Operand(destination), Operand(source_x), Operand(source_y),
2954                                        origin=origin)
2955    if peachpy.stream.active_stream is not None:
2956        peachpy.stream.active_stream.add_instruction(instruction)
2957    return instruction
2958
2959
2960def BICCS(destination, source_x, source_y=None):
2961    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2962    if source_y is None:
2963        (destination, source_x, source_y) = (destination, destination, source_x)
2964    instruction = ArithmeticInstruction('BICCS', Operand(destination), Operand(source_x), Operand(source_y),
2965                                        origin=origin)
2966    if peachpy.stream.active_stream is not None:
2967        peachpy.stream.active_stream.add_instruction(instruction)
2968    return instruction
2969
2970
2971def BICHS(destination, source_x, source_y=None):
2972    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2973    if source_y is None:
2974        (destination, source_x, source_y) = (destination, destination, source_x)
2975    instruction = ArithmeticInstruction('BICHS', Operand(destination), Operand(source_x), Operand(source_y),
2976                                        origin=origin)
2977    if peachpy.stream.active_stream is not None:
2978        peachpy.stream.active_stream.add_instruction(instruction)
2979    return instruction
2980
2981
2982def BICCC(destination, source_x, source_y=None):
2983    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2984    if source_y is None:
2985        (destination, source_x, source_y) = (destination, destination, source_x)
2986    instruction = ArithmeticInstruction('BICCC', Operand(destination), Operand(source_x), Operand(source_y),
2987                                        origin=origin)
2988    if peachpy.stream.active_stream is not None:
2989        peachpy.stream.active_stream.add_instruction(instruction)
2990    return instruction
2991
2992
2993def BICLO(destination, source_x, source_y=None):
2994    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
2995    if source_y is None:
2996        (destination, source_x, source_y) = (destination, destination, source_x)
2997    instruction = ArithmeticInstruction('BICLO', Operand(destination), Operand(source_x), Operand(source_y),
2998                                        origin=origin)
2999    if peachpy.stream.active_stream is not None:
3000        peachpy.stream.active_stream.add_instruction(instruction)
3001    return instruction
3002
3003
3004def BICMI(destination, source_x, source_y=None):
3005    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3006    if source_y is None:
3007        (destination, source_x, source_y) = (destination, destination, source_x)
3008    instruction = ArithmeticInstruction('BICMI', Operand(destination), Operand(source_x), Operand(source_y),
3009                                        origin=origin)
3010    if peachpy.stream.active_stream is not None:
3011        peachpy.stream.active_stream.add_instruction(instruction)
3012    return instruction
3013
3014
3015def BICPL(destination, source_x, source_y=None):
3016    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3017    if source_y is None:
3018        (destination, source_x, source_y) = (destination, destination, source_x)
3019    instruction = ArithmeticInstruction('BICPL', Operand(destination), Operand(source_x), Operand(source_y),
3020                                        origin=origin)
3021    if peachpy.stream.active_stream is not None:
3022        peachpy.stream.active_stream.add_instruction(instruction)
3023    return instruction
3024
3025
3026def BICVS(destination, source_x, source_y=None):
3027    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3028    if source_y is None:
3029        (destination, source_x, source_y) = (destination, destination, source_x)
3030    instruction = ArithmeticInstruction('BICVS', Operand(destination), Operand(source_x), Operand(source_y),
3031                                        origin=origin)
3032    if peachpy.stream.active_stream is not None:
3033        peachpy.stream.active_stream.add_instruction(instruction)
3034    return instruction
3035
3036
3037def BICVC(destination, source_x, source_y=None):
3038    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3039    if source_y is None:
3040        (destination, source_x, source_y) = (destination, destination, source_x)
3041    instruction = ArithmeticInstruction('BICVC', Operand(destination), Operand(source_x), Operand(source_y),
3042                                        origin=origin)
3043    if peachpy.stream.active_stream is not None:
3044        peachpy.stream.active_stream.add_instruction(instruction)
3045    return instruction
3046
3047
3048def BICHI(destination, source_x, source_y=None):
3049    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3050    if source_y is None:
3051        (destination, source_x, source_y) = (destination, destination, source_x)
3052    instruction = ArithmeticInstruction('BICHI', Operand(destination), Operand(source_x), Operand(source_y),
3053                                        origin=origin)
3054    if peachpy.stream.active_stream is not None:
3055        peachpy.stream.active_stream.add_instruction(instruction)
3056    return instruction
3057
3058
3059def BICLS(destination, source_x, source_y=None):
3060    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3061    if source_y is None:
3062        (destination, source_x, source_y) = (destination, destination, source_x)
3063    instruction = ArithmeticInstruction('BICLS', Operand(destination), Operand(source_x), Operand(source_y),
3064                                        origin=origin)
3065    if peachpy.stream.active_stream is not None:
3066        peachpy.stream.active_stream.add_instruction(instruction)
3067    return instruction
3068
3069
3070def BICGE(destination, source_x, source_y=None):
3071    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3072    if source_y is None:
3073        (destination, source_x, source_y) = (destination, destination, source_x)
3074    instruction = ArithmeticInstruction('BICGE', Operand(destination), Operand(source_x), Operand(source_y),
3075                                        origin=origin)
3076    if peachpy.stream.active_stream is not None:
3077        peachpy.stream.active_stream.add_instruction(instruction)
3078    return instruction
3079
3080
3081def BICLT(destination, source_x, source_y=None):
3082    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3083    if source_y is None:
3084        (destination, source_x, source_y) = (destination, destination, source_x)
3085    instruction = ArithmeticInstruction('BICLT', Operand(destination), Operand(source_x), Operand(source_y),
3086                                        origin=origin)
3087    if peachpy.stream.active_stream is not None:
3088        peachpy.stream.active_stream.add_instruction(instruction)
3089    return instruction
3090
3091
3092def BICGT(destination, source_x, source_y=None):
3093    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3094    if source_y is None:
3095        (destination, source_x, source_y) = (destination, destination, source_x)
3096    instruction = ArithmeticInstruction('BICGT', Operand(destination), Operand(source_x), Operand(source_y),
3097                                        origin=origin)
3098    if peachpy.stream.active_stream is not None:
3099        peachpy.stream.active_stream.add_instruction(instruction)
3100    return instruction
3101
3102
3103def BICLE(destination, source_x, source_y=None):
3104    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3105    if source_y is None:
3106        (destination, source_x, source_y) = (destination, destination, source_x)
3107    instruction = ArithmeticInstruction('BICLE', Operand(destination), Operand(source_x), Operand(source_y),
3108                                        origin=origin)
3109    if peachpy.stream.active_stream is not None:
3110        peachpy.stream.active_stream.add_instruction(instruction)
3111    return instruction
3112
3113
3114def BICS(destination, source_x, source_y=None):
3115    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3116    if source_y is None:
3117        (destination, source_x, source_y) = (destination, destination, source_x)
3118    instruction = ArithmeticInstruction('BICS', Operand(destination), Operand(source_x), Operand(source_y),
3119                                        origin=origin)
3120    if peachpy.stream.active_stream is not None:
3121        peachpy.stream.active_stream.add_instruction(instruction)
3122    return instruction
3123
3124
3125def BICSEQ(destination, source_x, source_y=None):
3126    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3127    if source_y is None:
3128        (destination, source_x, source_y) = (destination, destination, source_x)
3129    instruction = ArithmeticInstruction('BICSEQ', Operand(destination), Operand(source_x), Operand(source_y),
3130                                        origin=origin)
3131    if peachpy.stream.active_stream is not None:
3132        peachpy.stream.active_stream.add_instruction(instruction)
3133    return instruction
3134
3135
3136def BICSNE(destination, source_x, source_y=None):
3137    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3138    if source_y is None:
3139        (destination, source_x, source_y) = (destination, destination, source_x)
3140    instruction = ArithmeticInstruction('BICSNE', Operand(destination), Operand(source_x), Operand(source_y),
3141                                        origin=origin)
3142    if peachpy.stream.active_stream is not None:
3143        peachpy.stream.active_stream.add_instruction(instruction)
3144    return instruction
3145
3146
3147def BICSCS(destination, source_x, source_y=None):
3148    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3149    if source_y is None:
3150        (destination, source_x, source_y) = (destination, destination, source_x)
3151    instruction = ArithmeticInstruction('BICSCS', Operand(destination), Operand(source_x), Operand(source_y),
3152                                        origin=origin)
3153    if peachpy.stream.active_stream is not None:
3154        peachpy.stream.active_stream.add_instruction(instruction)
3155    return instruction
3156
3157
3158def BICSHS(destination, source_x, source_y=None):
3159    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3160    if source_y is None:
3161        (destination, source_x, source_y) = (destination, destination, source_x)
3162    instruction = ArithmeticInstruction('BICSHS', Operand(destination), Operand(source_x), Operand(source_y),
3163                                        origin=origin)
3164    if peachpy.stream.active_stream is not None:
3165        peachpy.stream.active_stream.add_instruction(instruction)
3166    return instruction
3167
3168
3169def BICSCC(destination, source_x, source_y=None):
3170    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3171    if source_y is None:
3172        (destination, source_x, source_y) = (destination, destination, source_x)
3173    instruction = ArithmeticInstruction('BICSCC', Operand(destination), Operand(source_x), Operand(source_y),
3174                                        origin=origin)
3175    if peachpy.stream.active_stream is not None:
3176        peachpy.stream.active_stream.add_instruction(instruction)
3177    return instruction
3178
3179
3180def BICSLO(destination, source_x, source_y=None):
3181    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3182    if source_y is None:
3183        (destination, source_x, source_y) = (destination, destination, source_x)
3184    instruction = ArithmeticInstruction('BICSLO', Operand(destination), Operand(source_x), Operand(source_y),
3185                                        origin=origin)
3186    if peachpy.stream.active_stream is not None:
3187        peachpy.stream.active_stream.add_instruction(instruction)
3188    return instruction
3189
3190
3191def BICSMI(destination, source_x, source_y=None):
3192    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3193    if source_y is None:
3194        (destination, source_x, source_y) = (destination, destination, source_x)
3195    instruction = ArithmeticInstruction('BICSMI', Operand(destination), Operand(source_x), Operand(source_y),
3196                                        origin=origin)
3197    if peachpy.stream.active_stream is not None:
3198        peachpy.stream.active_stream.add_instruction(instruction)
3199    return instruction
3200
3201
3202def BICSPL(destination, source_x, source_y=None):
3203    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3204    if source_y is None:
3205        (destination, source_x, source_y) = (destination, destination, source_x)
3206    instruction = ArithmeticInstruction('BICSPL', Operand(destination), Operand(source_x), Operand(source_y),
3207                                        origin=origin)
3208    if peachpy.stream.active_stream is not None:
3209        peachpy.stream.active_stream.add_instruction(instruction)
3210    return instruction
3211
3212
3213def BICSVS(destination, source_x, source_y=None):
3214    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3215    if source_y is None:
3216        (destination, source_x, source_y) = (destination, destination, source_x)
3217    instruction = ArithmeticInstruction('BICSVS', Operand(destination), Operand(source_x), Operand(source_y),
3218                                        origin=origin)
3219    if peachpy.stream.active_stream is not None:
3220        peachpy.stream.active_stream.add_instruction(instruction)
3221    return instruction
3222
3223
3224def BICSVC(destination, source_x, source_y=None):
3225    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3226    if source_y is None:
3227        (destination, source_x, source_y) = (destination, destination, source_x)
3228    instruction = ArithmeticInstruction('BICSVC', Operand(destination), Operand(source_x), Operand(source_y),
3229                                        origin=origin)
3230    if peachpy.stream.active_stream is not None:
3231        peachpy.stream.active_stream.add_instruction(instruction)
3232    return instruction
3233
3234
3235def BICSHI(destination, source_x, source_y=None):
3236    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3237    if source_y is None:
3238        (destination, source_x, source_y) = (destination, destination, source_x)
3239    instruction = ArithmeticInstruction('BICSHI', Operand(destination), Operand(source_x), Operand(source_y),
3240                                        origin=origin)
3241    if peachpy.stream.active_stream is not None:
3242        peachpy.stream.active_stream.add_instruction(instruction)
3243    return instruction
3244
3245
3246def BICSLS(destination, source_x, source_y=None):
3247    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3248    if source_y is None:
3249        (destination, source_x, source_y) = (destination, destination, source_x)
3250    instruction = ArithmeticInstruction('BICSLS', Operand(destination), Operand(source_x), Operand(source_y),
3251                                        origin=origin)
3252    if peachpy.stream.active_stream is not None:
3253        peachpy.stream.active_stream.add_instruction(instruction)
3254    return instruction
3255
3256
3257def BICSGE(destination, source_x, source_y=None):
3258    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3259    if source_y is None:
3260        (destination, source_x, source_y) = (destination, destination, source_x)
3261    instruction = ArithmeticInstruction('BICSGE', Operand(destination), Operand(source_x), Operand(source_y),
3262                                        origin=origin)
3263    if peachpy.stream.active_stream is not None:
3264        peachpy.stream.active_stream.add_instruction(instruction)
3265    return instruction
3266
3267
3268def BICSLT(destination, source_x, source_y=None):
3269    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3270    if source_y is None:
3271        (destination, source_x, source_y) = (destination, destination, source_x)
3272    instruction = ArithmeticInstruction('BICSLT', Operand(destination), Operand(source_x), Operand(source_y),
3273                                        origin=origin)
3274    if peachpy.stream.active_stream is not None:
3275        peachpy.stream.active_stream.add_instruction(instruction)
3276    return instruction
3277
3278
3279def BICSGT(destination, source_x, source_y=None):
3280    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3281    if source_y is None:
3282        (destination, source_x, source_y) = (destination, destination, source_x)
3283    instruction = ArithmeticInstruction('BICSGT', Operand(destination), Operand(source_x), Operand(source_y),
3284                                        origin=origin)
3285    if peachpy.stream.active_stream is not None:
3286        peachpy.stream.active_stream.add_instruction(instruction)
3287    return instruction
3288
3289
3290def BICSLE(destination, source_x, source_y=None):
3291    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3292    if source_y is None:
3293        (destination, source_x, source_y) = (destination, destination, source_x)
3294    instruction = ArithmeticInstruction('BICSLE', Operand(destination), Operand(source_x), Operand(source_y),
3295                                        origin=origin)
3296    if peachpy.stream.active_stream is not None:
3297        peachpy.stream.active_stream.add_instruction(instruction)
3298    return instruction
3299
3300
3301def ORR(destination, source_x, source_y=None):
3302    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3303    if source_y is None:
3304        (destination, source_x, source_y) = (destination, destination, source_x)
3305    instruction = ArithmeticInstruction('ORR', Operand(destination), Operand(source_x), Operand(source_y),
3306                                        origin=origin)
3307    if peachpy.stream.active_stream is not None:
3308        peachpy.stream.active_stream.add_instruction(instruction)
3309    return instruction
3310
3311
3312def ORREQ(destination, source_x, source_y=None):
3313    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3314    if source_y is None:
3315        (destination, source_x, source_y) = (destination, destination, source_x)
3316    instruction = ArithmeticInstruction('ORREQ', Operand(destination), Operand(source_x), Operand(source_y),
3317                                        origin=origin)
3318    if peachpy.stream.active_stream is not None:
3319        peachpy.stream.active_stream.add_instruction(instruction)
3320    return instruction
3321
3322
3323def ORRNE(destination, source_x, source_y=None):
3324    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3325    if source_y is None:
3326        (destination, source_x, source_y) = (destination, destination, source_x)
3327    instruction = ArithmeticInstruction('ORRNE', Operand(destination), Operand(source_x), Operand(source_y),
3328                                        origin=origin)
3329    if peachpy.stream.active_stream is not None:
3330        peachpy.stream.active_stream.add_instruction(instruction)
3331    return instruction
3332
3333
3334def ORRCS(destination, source_x, source_y=None):
3335    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3336    if source_y is None:
3337        (destination, source_x, source_y) = (destination, destination, source_x)
3338    instruction = ArithmeticInstruction('ORRCS', Operand(destination), Operand(source_x), Operand(source_y),
3339                                        origin=origin)
3340    if peachpy.stream.active_stream is not None:
3341        peachpy.stream.active_stream.add_instruction(instruction)
3342    return instruction
3343
3344
3345def ORRHS(destination, source_x, source_y=None):
3346    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3347    if source_y is None:
3348        (destination, source_x, source_y) = (destination, destination, source_x)
3349    instruction = ArithmeticInstruction('ORRHS', Operand(destination), Operand(source_x), Operand(source_y),
3350                                        origin=origin)
3351    if peachpy.stream.active_stream is not None:
3352        peachpy.stream.active_stream.add_instruction(instruction)
3353    return instruction
3354
3355
3356def ORRCC(destination, source_x, source_y=None):
3357    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3358    if source_y is None:
3359        (destination, source_x, source_y) = (destination, destination, source_x)
3360    instruction = ArithmeticInstruction('ORRCC', Operand(destination), Operand(source_x), Operand(source_y),
3361                                        origin=origin)
3362    if peachpy.stream.active_stream is not None:
3363        peachpy.stream.active_stream.add_instruction(instruction)
3364    return instruction
3365
3366
3367def ORRLO(destination, source_x, source_y=None):
3368    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3369    if source_y is None:
3370        (destination, source_x, source_y) = (destination, destination, source_x)
3371    instruction = ArithmeticInstruction('ORRLO', Operand(destination), Operand(source_x), Operand(source_y),
3372                                        origin=origin)
3373    if peachpy.stream.active_stream is not None:
3374        peachpy.stream.active_stream.add_instruction(instruction)
3375    return instruction
3376
3377
3378def ORRMI(destination, source_x, source_y=None):
3379    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3380    if source_y is None:
3381        (destination, source_x, source_y) = (destination, destination, source_x)
3382    instruction = ArithmeticInstruction('ORRMI', Operand(destination), Operand(source_x), Operand(source_y),
3383                                        origin=origin)
3384    if peachpy.stream.active_stream is not None:
3385        peachpy.stream.active_stream.add_instruction(instruction)
3386    return instruction
3387
3388
3389def ORRPL(destination, source_x, source_y=None):
3390    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3391    if source_y is None:
3392        (destination, source_x, source_y) = (destination, destination, source_x)
3393    instruction = ArithmeticInstruction('ORRPL', Operand(destination), Operand(source_x), Operand(source_y),
3394                                        origin=origin)
3395    if peachpy.stream.active_stream is not None:
3396        peachpy.stream.active_stream.add_instruction(instruction)
3397    return instruction
3398
3399
3400def ORRVS(destination, source_x, source_y=None):
3401    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3402    if source_y is None:
3403        (destination, source_x, source_y) = (destination, destination, source_x)
3404    instruction = ArithmeticInstruction('ORRVS', Operand(destination), Operand(source_x), Operand(source_y),
3405                                        origin=origin)
3406    if peachpy.stream.active_stream is not None:
3407        peachpy.stream.active_stream.add_instruction(instruction)
3408    return instruction
3409
3410
3411def ORRVC(destination, source_x, source_y=None):
3412    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3413    if source_y is None:
3414        (destination, source_x, source_y) = (destination, destination, source_x)
3415    instruction = ArithmeticInstruction('ORRVC', Operand(destination), Operand(source_x), Operand(source_y),
3416                                        origin=origin)
3417    if peachpy.stream.active_stream is not None:
3418        peachpy.stream.active_stream.add_instruction(instruction)
3419    return instruction
3420
3421
3422def ORRHI(destination, source_x, source_y=None):
3423    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3424    if source_y is None:
3425        (destination, source_x, source_y) = (destination, destination, source_x)
3426    instruction = ArithmeticInstruction('ORRHI', Operand(destination), Operand(source_x), Operand(source_y),
3427                                        origin=origin)
3428    if peachpy.stream.active_stream is not None:
3429        peachpy.stream.active_stream.add_instruction(instruction)
3430    return instruction
3431
3432
3433def ORRLS(destination, source_x, source_y=None):
3434    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3435    if source_y is None:
3436        (destination, source_x, source_y) = (destination, destination, source_x)
3437    instruction = ArithmeticInstruction('ORRLS', Operand(destination), Operand(source_x), Operand(source_y),
3438                                        origin=origin)
3439    if peachpy.stream.active_stream is not None:
3440        peachpy.stream.active_stream.add_instruction(instruction)
3441    return instruction
3442
3443
3444def ORRGE(destination, source_x, source_y=None):
3445    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3446    if source_y is None:
3447        (destination, source_x, source_y) = (destination, destination, source_x)
3448    instruction = ArithmeticInstruction('ORRGE', Operand(destination), Operand(source_x), Operand(source_y),
3449                                        origin=origin)
3450    if peachpy.stream.active_stream is not None:
3451        peachpy.stream.active_stream.add_instruction(instruction)
3452    return instruction
3453
3454
3455def ORRLT(destination, source_x, source_y=None):
3456    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3457    if source_y is None:
3458        (destination, source_x, source_y) = (destination, destination, source_x)
3459    instruction = ArithmeticInstruction('ORRLT', Operand(destination), Operand(source_x), Operand(source_y),
3460                                        origin=origin)
3461    if peachpy.stream.active_stream is not None:
3462        peachpy.stream.active_stream.add_instruction(instruction)
3463    return instruction
3464
3465
3466def ORRGT(destination, source_x, source_y=None):
3467    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3468    if source_y is None:
3469        (destination, source_x, source_y) = (destination, destination, source_x)
3470    instruction = ArithmeticInstruction('ORRGT', Operand(destination), Operand(source_x), Operand(source_y),
3471                                        origin=origin)
3472    if peachpy.stream.active_stream is not None:
3473        peachpy.stream.active_stream.add_instruction(instruction)
3474    return instruction
3475
3476
3477def ORRLE(destination, source_x, source_y=None):
3478    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3479    if source_y is None:
3480        (destination, source_x, source_y) = (destination, destination, source_x)
3481    instruction = ArithmeticInstruction('ORRLE', Operand(destination), Operand(source_x), Operand(source_y),
3482                                        origin=origin)
3483    if peachpy.stream.active_stream is not None:
3484        peachpy.stream.active_stream.add_instruction(instruction)
3485    return instruction
3486
3487
3488def ORRS(destination, source_x, source_y=None):
3489    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3490    if source_y is None:
3491        (destination, source_x, source_y) = (destination, destination, source_x)
3492    instruction = ArithmeticInstruction('ORRS', Operand(destination), Operand(source_x), Operand(source_y),
3493                                        origin=origin)
3494    if peachpy.stream.active_stream is not None:
3495        peachpy.stream.active_stream.add_instruction(instruction)
3496    return instruction
3497
3498
3499def ORRSEQ(destination, source_x, source_y=None):
3500    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3501    if source_y is None:
3502        (destination, source_x, source_y) = (destination, destination, source_x)
3503    instruction = ArithmeticInstruction('ORRSEQ', Operand(destination), Operand(source_x), Operand(source_y),
3504                                        origin=origin)
3505    if peachpy.stream.active_stream is not None:
3506        peachpy.stream.active_stream.add_instruction(instruction)
3507    return instruction
3508
3509
3510def ORRSNE(destination, source_x, source_y=None):
3511    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3512    if source_y is None:
3513        (destination, source_x, source_y) = (destination, destination, source_x)
3514    instruction = ArithmeticInstruction('ORRSNE', Operand(destination), Operand(source_x), Operand(source_y),
3515                                        origin=origin)
3516    if peachpy.stream.active_stream is not None:
3517        peachpy.stream.active_stream.add_instruction(instruction)
3518    return instruction
3519
3520
3521def ORRSCS(destination, source_x, source_y=None):
3522    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3523    if source_y is None:
3524        (destination, source_x, source_y) = (destination, destination, source_x)
3525    instruction = ArithmeticInstruction('ORRSCS', Operand(destination), Operand(source_x), Operand(source_y),
3526                                        origin=origin)
3527    if peachpy.stream.active_stream is not None:
3528        peachpy.stream.active_stream.add_instruction(instruction)
3529    return instruction
3530
3531
3532def ORRSHS(destination, source_x, source_y=None):
3533    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3534    if source_y is None:
3535        (destination, source_x, source_y) = (destination, destination, source_x)
3536    instruction = ArithmeticInstruction('ORRSHS', Operand(destination), Operand(source_x), Operand(source_y),
3537                                        origin=origin)
3538    if peachpy.stream.active_stream is not None:
3539        peachpy.stream.active_stream.add_instruction(instruction)
3540    return instruction
3541
3542
3543def ORRSCC(destination, source_x, source_y=None):
3544    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3545    if source_y is None:
3546        (destination, source_x, source_y) = (destination, destination, source_x)
3547    instruction = ArithmeticInstruction('ORRSCC', Operand(destination), Operand(source_x), Operand(source_y),
3548                                        origin=origin)
3549    if peachpy.stream.active_stream is not None:
3550        peachpy.stream.active_stream.add_instruction(instruction)
3551    return instruction
3552
3553
3554def ORRSLO(destination, source_x, source_y=None):
3555    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3556    if source_y is None:
3557        (destination, source_x, source_y) = (destination, destination, source_x)
3558    instruction = ArithmeticInstruction('ORRSLO', Operand(destination), Operand(source_x), Operand(source_y),
3559                                        origin=origin)
3560    if peachpy.stream.active_stream is not None:
3561        peachpy.stream.active_stream.add_instruction(instruction)
3562    return instruction
3563
3564
3565def ORRSMI(destination, source_x, source_y=None):
3566    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3567    if source_y is None:
3568        (destination, source_x, source_y) = (destination, destination, source_x)
3569    instruction = ArithmeticInstruction('ORRSMI', Operand(destination), Operand(source_x), Operand(source_y),
3570                                        origin=origin)
3571    if peachpy.stream.active_stream is not None:
3572        peachpy.stream.active_stream.add_instruction(instruction)
3573    return instruction
3574
3575
3576def ORRSPL(destination, source_x, source_y=None):
3577    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3578    if source_y is None:
3579        (destination, source_x, source_y) = (destination, destination, source_x)
3580    instruction = ArithmeticInstruction('ORRSPL', Operand(destination), Operand(source_x), Operand(source_y),
3581                                        origin=origin)
3582    if peachpy.stream.active_stream is not None:
3583        peachpy.stream.active_stream.add_instruction(instruction)
3584    return instruction
3585
3586
3587def ORRSVS(destination, source_x, source_y=None):
3588    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3589    if source_y is None:
3590        (destination, source_x, source_y) = (destination, destination, source_x)
3591    instruction = ArithmeticInstruction('ORRSVS', Operand(destination), Operand(source_x), Operand(source_y),
3592                                        origin=origin)
3593    if peachpy.stream.active_stream is not None:
3594        peachpy.stream.active_stream.add_instruction(instruction)
3595    return instruction
3596
3597
3598def ORRSVC(destination, source_x, source_y=None):
3599    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3600    if source_y is None:
3601        (destination, source_x, source_y) = (destination, destination, source_x)
3602    instruction = ArithmeticInstruction('ORRSVC', Operand(destination), Operand(source_x), Operand(source_y),
3603                                        origin=origin)
3604    if peachpy.stream.active_stream is not None:
3605        peachpy.stream.active_stream.add_instruction(instruction)
3606    return instruction
3607
3608
3609def ORRSHI(destination, source_x, source_y=None):
3610    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3611    if source_y is None:
3612        (destination, source_x, source_y) = (destination, destination, source_x)
3613    instruction = ArithmeticInstruction('ORRSHI', Operand(destination), Operand(source_x), Operand(source_y),
3614                                        origin=origin)
3615    if peachpy.stream.active_stream is not None:
3616        peachpy.stream.active_stream.add_instruction(instruction)
3617    return instruction
3618
3619
3620def ORRSLS(destination, source_x, source_y=None):
3621    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3622    if source_y is None:
3623        (destination, source_x, source_y) = (destination, destination, source_x)
3624    instruction = ArithmeticInstruction('ORRSLS', Operand(destination), Operand(source_x), Operand(source_y),
3625                                        origin=origin)
3626    if peachpy.stream.active_stream is not None:
3627        peachpy.stream.active_stream.add_instruction(instruction)
3628    return instruction
3629
3630
3631def ORRSGE(destination, source_x, source_y=None):
3632    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3633    if source_y is None:
3634        (destination, source_x, source_y) = (destination, destination, source_x)
3635    instruction = ArithmeticInstruction('ORRSGE', Operand(destination), Operand(source_x), Operand(source_y),
3636                                        origin=origin)
3637    if peachpy.stream.active_stream is not None:
3638        peachpy.stream.active_stream.add_instruction(instruction)
3639    return instruction
3640
3641
3642def ORRSLT(destination, source_x, source_y=None):
3643    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3644    if source_y is None:
3645        (destination, source_x, source_y) = (destination, destination, source_x)
3646    instruction = ArithmeticInstruction('ORRSLT', Operand(destination), Operand(source_x), Operand(source_y),
3647                                        origin=origin)
3648    if peachpy.stream.active_stream is not None:
3649        peachpy.stream.active_stream.add_instruction(instruction)
3650    return instruction
3651
3652
3653def ORRSGT(destination, source_x, source_y=None):
3654    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3655    if source_y is None:
3656        (destination, source_x, source_y) = (destination, destination, source_x)
3657    instruction = ArithmeticInstruction('ORRSGT', Operand(destination), Operand(source_x), Operand(source_y),
3658                                        origin=origin)
3659    if peachpy.stream.active_stream is not None:
3660        peachpy.stream.active_stream.add_instruction(instruction)
3661    return instruction
3662
3663
3664def ORRSLE(destination, source_x, source_y=None):
3665    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3666    if source_y is None:
3667        (destination, source_x, source_y) = (destination, destination, source_x)
3668    instruction = ArithmeticInstruction('ORRSLE', Operand(destination), Operand(source_x), Operand(source_y),
3669                                        origin=origin)
3670    if peachpy.stream.active_stream is not None:
3671        peachpy.stream.active_stream.add_instruction(instruction)
3672    return instruction
3673
3674
3675def EOR(destination, source_x, source_y=None):
3676    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3677    if source_y is None:
3678        (destination, source_x, source_y) = (destination, destination, source_x)
3679    instruction = ArithmeticInstruction('EOR', Operand(destination), Operand(source_x), Operand(source_y),
3680                                        origin=origin)
3681    if peachpy.stream.active_stream is not None:
3682        peachpy.stream.active_stream.add_instruction(instruction)
3683    return instruction
3684
3685
3686def EOREQ(destination, source_x, source_y=None):
3687    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3688    if source_y is None:
3689        (destination, source_x, source_y) = (destination, destination, source_x)
3690    instruction = ArithmeticInstruction('EOREQ', Operand(destination), Operand(source_x), Operand(source_y),
3691                                        origin=origin)
3692    if peachpy.stream.active_stream is not None:
3693        peachpy.stream.active_stream.add_instruction(instruction)
3694    return instruction
3695
3696
3697def EORNE(destination, source_x, source_y=None):
3698    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3699    if source_y is None:
3700        (destination, source_x, source_y) = (destination, destination, source_x)
3701    instruction = ArithmeticInstruction('EORNE', Operand(destination), Operand(source_x), Operand(source_y),
3702                                        origin=origin)
3703    if peachpy.stream.active_stream is not None:
3704        peachpy.stream.active_stream.add_instruction(instruction)
3705    return instruction
3706
3707
3708def EORCS(destination, source_x, source_y=None):
3709    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3710    if source_y is None:
3711        (destination, source_x, source_y) = (destination, destination, source_x)
3712    instruction = ArithmeticInstruction('EORCS', Operand(destination), Operand(source_x), Operand(source_y),
3713                                        origin=origin)
3714    if peachpy.stream.active_stream is not None:
3715        peachpy.stream.active_stream.add_instruction(instruction)
3716    return instruction
3717
3718
3719def EORHS(destination, source_x, source_y=None):
3720    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3721    if source_y is None:
3722        (destination, source_x, source_y) = (destination, destination, source_x)
3723    instruction = ArithmeticInstruction('EORHS', Operand(destination), Operand(source_x), Operand(source_y),
3724                                        origin=origin)
3725    if peachpy.stream.active_stream is not None:
3726        peachpy.stream.active_stream.add_instruction(instruction)
3727    return instruction
3728
3729
3730def EORCC(destination, source_x, source_y=None):
3731    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3732    if source_y is None:
3733        (destination, source_x, source_y) = (destination, destination, source_x)
3734    instruction = ArithmeticInstruction('EORCC', Operand(destination), Operand(source_x), Operand(source_y),
3735                                        origin=origin)
3736    if peachpy.stream.active_stream is not None:
3737        peachpy.stream.active_stream.add_instruction(instruction)
3738    return instruction
3739
3740
3741def EORLO(destination, source_x, source_y=None):
3742    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3743    if source_y is None:
3744        (destination, source_x, source_y) = (destination, destination, source_x)
3745    instruction = ArithmeticInstruction('EORLO', Operand(destination), Operand(source_x), Operand(source_y),
3746                                        origin=origin)
3747    if peachpy.stream.active_stream is not None:
3748        peachpy.stream.active_stream.add_instruction(instruction)
3749    return instruction
3750
3751
3752def EORMI(destination, source_x, source_y=None):
3753    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3754    if source_y is None:
3755        (destination, source_x, source_y) = (destination, destination, source_x)
3756    instruction = ArithmeticInstruction('EORMI', Operand(destination), Operand(source_x), Operand(source_y),
3757                                        origin=origin)
3758    if peachpy.stream.active_stream is not None:
3759        peachpy.stream.active_stream.add_instruction(instruction)
3760    return instruction
3761
3762
3763def EORPL(destination, source_x, source_y=None):
3764    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3765    if source_y is None:
3766        (destination, source_x, source_y) = (destination, destination, source_x)
3767    instruction = ArithmeticInstruction('EORPL', Operand(destination), Operand(source_x), Operand(source_y),
3768                                        origin=origin)
3769    if peachpy.stream.active_stream is not None:
3770        peachpy.stream.active_stream.add_instruction(instruction)
3771    return instruction
3772
3773
3774def EORVS(destination, source_x, source_y=None):
3775    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3776    if source_y is None:
3777        (destination, source_x, source_y) = (destination, destination, source_x)
3778    instruction = ArithmeticInstruction('EORVS', Operand(destination), Operand(source_x), Operand(source_y),
3779                                        origin=origin)
3780    if peachpy.stream.active_stream is not None:
3781        peachpy.stream.active_stream.add_instruction(instruction)
3782    return instruction
3783
3784
3785def EORVC(destination, source_x, source_y=None):
3786    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3787    if source_y is None:
3788        (destination, source_x, source_y) = (destination, destination, source_x)
3789    instruction = ArithmeticInstruction('EORVC', Operand(destination), Operand(source_x), Operand(source_y),
3790                                        origin=origin)
3791    if peachpy.stream.active_stream is not None:
3792        peachpy.stream.active_stream.add_instruction(instruction)
3793    return instruction
3794
3795
3796def EORHI(destination, source_x, source_y=None):
3797    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3798    if source_y is None:
3799        (destination, source_x, source_y) = (destination, destination, source_x)
3800    instruction = ArithmeticInstruction('EORHI', Operand(destination), Operand(source_x), Operand(source_y),
3801                                        origin=origin)
3802    if peachpy.stream.active_stream is not None:
3803        peachpy.stream.active_stream.add_instruction(instruction)
3804    return instruction
3805
3806
3807def EORLS(destination, source_x, source_y=None):
3808    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3809    if source_y is None:
3810        (destination, source_x, source_y) = (destination, destination, source_x)
3811    instruction = ArithmeticInstruction('EORLS', Operand(destination), Operand(source_x), Operand(source_y),
3812                                        origin=origin)
3813    if peachpy.stream.active_stream is not None:
3814        peachpy.stream.active_stream.add_instruction(instruction)
3815    return instruction
3816
3817
3818def EORGE(destination, source_x, source_y=None):
3819    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3820    if source_y is None:
3821        (destination, source_x, source_y) = (destination, destination, source_x)
3822    instruction = ArithmeticInstruction('EORGE', Operand(destination), Operand(source_x), Operand(source_y),
3823                                        origin=origin)
3824    if peachpy.stream.active_stream is not None:
3825        peachpy.stream.active_stream.add_instruction(instruction)
3826    return instruction
3827
3828
3829def EORLT(destination, source_x, source_y=None):
3830    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3831    if source_y is None:
3832        (destination, source_x, source_y) = (destination, destination, source_x)
3833    instruction = ArithmeticInstruction('EORLT', Operand(destination), Operand(source_x), Operand(source_y),
3834                                        origin=origin)
3835    if peachpy.stream.active_stream is not None:
3836        peachpy.stream.active_stream.add_instruction(instruction)
3837    return instruction
3838
3839
3840def EORGT(destination, source_x, source_y=None):
3841    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3842    if source_y is None:
3843        (destination, source_x, source_y) = (destination, destination, source_x)
3844    instruction = ArithmeticInstruction('EORGT', Operand(destination), Operand(source_x), Operand(source_y),
3845                                        origin=origin)
3846    if peachpy.stream.active_stream is not None:
3847        peachpy.stream.active_stream.add_instruction(instruction)
3848    return instruction
3849
3850
3851def EORLE(destination, source_x, source_y=None):
3852    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3853    if source_y is None:
3854        (destination, source_x, source_y) = (destination, destination, source_x)
3855    instruction = ArithmeticInstruction('EORLE', Operand(destination), Operand(source_x), Operand(source_y),
3856                                        origin=origin)
3857    if peachpy.stream.active_stream is not None:
3858        peachpy.stream.active_stream.add_instruction(instruction)
3859    return instruction
3860
3861
3862def EORS(destination, source_x, source_y=None):
3863    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3864    if source_y is None:
3865        (destination, source_x, source_y) = (destination, destination, source_x)
3866    instruction = ArithmeticInstruction('EORS', Operand(destination), Operand(source_x), Operand(source_y),
3867                                        origin=origin)
3868    if peachpy.stream.active_stream is not None:
3869        peachpy.stream.active_stream.add_instruction(instruction)
3870    return instruction
3871
3872
3873def EORSEQ(destination, source_x, source_y=None):
3874    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3875    if source_y is None:
3876        (destination, source_x, source_y) = (destination, destination, source_x)
3877    instruction = ArithmeticInstruction('EORSEQ', Operand(destination), Operand(source_x), Operand(source_y),
3878                                        origin=origin)
3879    if peachpy.stream.active_stream is not None:
3880        peachpy.stream.active_stream.add_instruction(instruction)
3881    return instruction
3882
3883
3884def EORSNE(destination, source_x, source_y=None):
3885    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3886    if source_y is None:
3887        (destination, source_x, source_y) = (destination, destination, source_x)
3888    instruction = ArithmeticInstruction('EORSNE', Operand(destination), Operand(source_x), Operand(source_y),
3889                                        origin=origin)
3890    if peachpy.stream.active_stream is not None:
3891        peachpy.stream.active_stream.add_instruction(instruction)
3892    return instruction
3893
3894
3895def EORSCS(destination, source_x, source_y=None):
3896    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3897    if source_y is None:
3898        (destination, source_x, source_y) = (destination, destination, source_x)
3899    instruction = ArithmeticInstruction('EORSCS', Operand(destination), Operand(source_x), Operand(source_y),
3900                                        origin=origin)
3901    if peachpy.stream.active_stream is not None:
3902        peachpy.stream.active_stream.add_instruction(instruction)
3903    return instruction
3904
3905
3906def EORSHS(destination, source_x, source_y=None):
3907    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3908    if source_y is None:
3909        (destination, source_x, source_y) = (destination, destination, source_x)
3910    instruction = ArithmeticInstruction('EORSHS', Operand(destination), Operand(source_x), Operand(source_y),
3911                                        origin=origin)
3912    if peachpy.stream.active_stream is not None:
3913        peachpy.stream.active_stream.add_instruction(instruction)
3914    return instruction
3915
3916
3917def EORSCC(destination, source_x, source_y=None):
3918    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3919    if source_y is None:
3920        (destination, source_x, source_y) = (destination, destination, source_x)
3921    instruction = ArithmeticInstruction('EORSCC', Operand(destination), Operand(source_x), Operand(source_y),
3922                                        origin=origin)
3923    if peachpy.stream.active_stream is not None:
3924        peachpy.stream.active_stream.add_instruction(instruction)
3925    return instruction
3926
3927
3928def EORSLO(destination, source_x, source_y=None):
3929    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3930    if source_y is None:
3931        (destination, source_x, source_y) = (destination, destination, source_x)
3932    instruction = ArithmeticInstruction('EORSLO', Operand(destination), Operand(source_x), Operand(source_y),
3933                                        origin=origin)
3934    if peachpy.stream.active_stream is not None:
3935        peachpy.stream.active_stream.add_instruction(instruction)
3936    return instruction
3937
3938
3939def EORSMI(destination, source_x, source_y=None):
3940    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3941    if source_y is None:
3942        (destination, source_x, source_y) = (destination, destination, source_x)
3943    instruction = ArithmeticInstruction('EORSMI', Operand(destination), Operand(source_x), Operand(source_y),
3944                                        origin=origin)
3945    if peachpy.stream.active_stream is not None:
3946        peachpy.stream.active_stream.add_instruction(instruction)
3947    return instruction
3948
3949
3950def EORSPL(destination, source_x, source_y=None):
3951    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3952    if source_y is None:
3953        (destination, source_x, source_y) = (destination, destination, source_x)
3954    instruction = ArithmeticInstruction('EORSPL', Operand(destination), Operand(source_x), Operand(source_y),
3955                                        origin=origin)
3956    if peachpy.stream.active_stream is not None:
3957        peachpy.stream.active_stream.add_instruction(instruction)
3958    return instruction
3959
3960
3961def EORSVS(destination, source_x, source_y=None):
3962    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3963    if source_y is None:
3964        (destination, source_x, source_y) = (destination, destination, source_x)
3965    instruction = ArithmeticInstruction('EORSVS', Operand(destination), Operand(source_x), Operand(source_y),
3966                                        origin=origin)
3967    if peachpy.stream.active_stream is not None:
3968        peachpy.stream.active_stream.add_instruction(instruction)
3969    return instruction
3970
3971
3972def EORSVC(destination, source_x, source_y=None):
3973    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3974    if source_y is None:
3975        (destination, source_x, source_y) = (destination, destination, source_x)
3976    instruction = ArithmeticInstruction('EORSVC', Operand(destination), Operand(source_x), Operand(source_y),
3977                                        origin=origin)
3978    if peachpy.stream.active_stream is not None:
3979        peachpy.stream.active_stream.add_instruction(instruction)
3980    return instruction
3981
3982
3983def EORSHI(destination, source_x, source_y=None):
3984    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3985    if source_y is None:
3986        (destination, source_x, source_y) = (destination, destination, source_x)
3987    instruction = ArithmeticInstruction('EORSHI', Operand(destination), Operand(source_x), Operand(source_y),
3988                                        origin=origin)
3989    if peachpy.stream.active_stream is not None:
3990        peachpy.stream.active_stream.add_instruction(instruction)
3991    return instruction
3992
3993
3994def EORSLS(destination, source_x, source_y=None):
3995    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
3996    if source_y is None:
3997        (destination, source_x, source_y) = (destination, destination, source_x)
3998    instruction = ArithmeticInstruction('EORSLS', Operand(destination), Operand(source_x), Operand(source_y),
3999                                        origin=origin)
4000    if peachpy.stream.active_stream is not None:
4001        peachpy.stream.active_stream.add_instruction(instruction)
4002    return instruction
4003
4004
4005def EORSGE(destination, source_x, source_y=None):
4006    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4007    if source_y is None:
4008        (destination, source_x, source_y) = (destination, destination, source_x)
4009    instruction = ArithmeticInstruction('EORSGE', Operand(destination), Operand(source_x), Operand(source_y),
4010                                        origin=origin)
4011    if peachpy.stream.active_stream is not None:
4012        peachpy.stream.active_stream.add_instruction(instruction)
4013    return instruction
4014
4015
4016def EORSLT(destination, source_x, source_y=None):
4017    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4018    if source_y is None:
4019        (destination, source_x, source_y) = (destination, destination, source_x)
4020    instruction = ArithmeticInstruction('EORSLT', Operand(destination), Operand(source_x), Operand(source_y),
4021                                        origin=origin)
4022    if peachpy.stream.active_stream is not None:
4023        peachpy.stream.active_stream.add_instruction(instruction)
4024    return instruction
4025
4026
4027def EORSGT(destination, source_x, source_y=None):
4028    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4029    if source_y is None:
4030        (destination, source_x, source_y) = (destination, destination, source_x)
4031    instruction = ArithmeticInstruction('EORSGT', Operand(destination), Operand(source_x), Operand(source_y),
4032                                        origin=origin)
4033    if peachpy.stream.active_stream is not None:
4034        peachpy.stream.active_stream.add_instruction(instruction)
4035    return instruction
4036
4037
4038def EORSLE(destination, source_x, source_y=None):
4039    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4040    if source_y is None:
4041        (destination, source_x, source_y) = (destination, destination, source_x)
4042    instruction = ArithmeticInstruction('EORSLE', Operand(destination), Operand(source_x), Operand(source_y),
4043                                        origin=origin)
4044    if peachpy.stream.active_stream is not None:
4045        peachpy.stream.active_stream.add_instruction(instruction)
4046    return instruction
4047
4048
4049def LSL(destination, source_x, source_y=None):
4050    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4051    if source_y is None:
4052        (destination, source_x, source_y) = (destination, destination, source_x)
4053    instruction = ShiftInstruction('LSL', Operand(destination), Operand(source_x), Operand(source_y), origin=origin)
4054    if peachpy.stream.active_stream is not None:
4055        peachpy.stream.active_stream.add_instruction(instruction)
4056    return instruction
4057
4058
4059def LSR(destination, source_x, source_y=None):
4060    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4061    if source_y is None:
4062        (destination, source_x, source_y) = (destination, destination, source_x)
4063    instruction = ShiftInstruction('LSR', Operand(destination), Operand(source_x), Operand(source_y), origin=origin)
4064    if peachpy.stream.active_stream is not None:
4065        peachpy.stream.active_stream.add_instruction(instruction)
4066    return instruction
4067
4068
4069def ASR(destination, source_x, source_y=None):
4070    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4071    if source_y is None:
4072        (destination, source_x, source_y) = (destination, destination, source_x)
4073    instruction = ShiftInstruction('ASR', Operand(destination), Operand(source_x), Operand(source_y), origin=origin)
4074    if peachpy.stream.active_stream is not None:
4075        peachpy.stream.active_stream.add_instruction(instruction)
4076    return instruction
4077
4078
4079def CMP(source_x, source_y):
4080    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4081    instruction = CompareInstruction('CMP', Operand(source_x), Operand(source_y), origin=origin)
4082    if peachpy.stream.active_stream is not None:
4083        peachpy.stream.active_stream.add_instruction(instruction)
4084    return instruction
4085
4086
4087def CMPEQ(source_x, source_y):
4088    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4089    instruction = CompareInstruction('CMPEQ', Operand(source_x), Operand(source_y), origin=origin)
4090    if peachpy.stream.active_stream is not None:
4091        peachpy.stream.active_stream.add_instruction(instruction)
4092    return instruction
4093
4094
4095def CMPNE(source_x, source_y):
4096    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4097    instruction = CompareInstruction('CMPNE', Operand(source_x), Operand(source_y), origin=origin)
4098    if peachpy.stream.active_stream is not None:
4099        peachpy.stream.active_stream.add_instruction(instruction)
4100    return instruction
4101
4102
4103def CMPCS(source_x, source_y):
4104    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4105    instruction = CompareInstruction('CMPCS', Operand(source_x), Operand(source_y), origin=origin)
4106    if peachpy.stream.active_stream is not None:
4107        peachpy.stream.active_stream.add_instruction(instruction)
4108    return instruction
4109
4110
4111def CMPHS(source_x, source_y):
4112    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4113    instruction = CompareInstruction('CMPHS', Operand(source_x), Operand(source_y), origin=origin)
4114    if peachpy.stream.active_stream is not None:
4115        peachpy.stream.active_stream.add_instruction(instruction)
4116    return instruction
4117
4118
4119def CMPCC(source_x, source_y):
4120    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4121    instruction = CompareInstruction('CMPCC', Operand(source_x), Operand(source_y), origin=origin)
4122    if peachpy.stream.active_stream is not None:
4123        peachpy.stream.active_stream.add_instruction(instruction)
4124    return instruction
4125
4126
4127def CMPLO(source_x, source_y):
4128    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4129    instruction = CompareInstruction('CMPLO', Operand(source_x), Operand(source_y), origin=origin)
4130    if peachpy.stream.active_stream is not None:
4131        peachpy.stream.active_stream.add_instruction(instruction)
4132    return instruction
4133
4134
4135def CMPMI(source_x, source_y):
4136    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4137    instruction = CompareInstruction('CMPMI', Operand(source_x), Operand(source_y), origin=origin)
4138    if peachpy.stream.active_stream is not None:
4139        peachpy.stream.active_stream.add_instruction(instruction)
4140    return instruction
4141
4142
4143def CMPPL(source_x, source_y):
4144    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4145    instruction = CompareInstruction('CMPPL', Operand(source_x), Operand(source_y), origin=origin)
4146    if peachpy.stream.active_stream is not None:
4147        peachpy.stream.active_stream.add_instruction(instruction)
4148    return instruction
4149
4150
4151def CMPVS(source_x, source_y):
4152    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4153    instruction = CompareInstruction('CMPVS', Operand(source_x), Operand(source_y), origin=origin)
4154    if peachpy.stream.active_stream is not None:
4155        peachpy.stream.active_stream.add_instruction(instruction)
4156    return instruction
4157
4158
4159def CMPVC(source_x, source_y):
4160    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4161    instruction = CompareInstruction('CMPVC', Operand(source_x), Operand(source_y), origin=origin)
4162    if peachpy.stream.active_stream is not None:
4163        peachpy.stream.active_stream.add_instruction(instruction)
4164    return instruction
4165
4166
4167def CMPHI(source_x, source_y):
4168    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4169    instruction = CompareInstruction('CMPHI', Operand(source_x), Operand(source_y), origin=origin)
4170    if peachpy.stream.active_stream is not None:
4171        peachpy.stream.active_stream.add_instruction(instruction)
4172    return instruction
4173
4174
4175def CMPLS(source_x, source_y):
4176    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4177    instruction = CompareInstruction('CMPLS', Operand(source_x), Operand(source_y), origin=origin)
4178    if peachpy.stream.active_stream is not None:
4179        peachpy.stream.active_stream.add_instruction(instruction)
4180    return instruction
4181
4182
4183def CMPGE(source_x, source_y):
4184    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4185    instruction = CompareInstruction('CMPGE', Operand(source_x), Operand(source_y), origin=origin)
4186    if peachpy.stream.active_stream is not None:
4187        peachpy.stream.active_stream.add_instruction(instruction)
4188    return instruction
4189
4190
4191def CMPLT(source_x, source_y):
4192    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4193    instruction = CompareInstruction('CMPLT', Operand(source_x), Operand(source_y), origin=origin)
4194    if peachpy.stream.active_stream is not None:
4195        peachpy.stream.active_stream.add_instruction(instruction)
4196    return instruction
4197
4198
4199def CMPGT(source_x, source_y):
4200    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4201    instruction = CompareInstruction('CMPGT', Operand(source_x), Operand(source_y), origin=origin)
4202    if peachpy.stream.active_stream is not None:
4203        peachpy.stream.active_stream.add_instruction(instruction)
4204    return instruction
4205
4206
4207def CMPLE(source_x, source_y):
4208    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4209    instruction = CompareInstruction('CMPLE', Operand(source_x), Operand(source_y), origin=origin)
4210    if peachpy.stream.active_stream is not None:
4211        peachpy.stream.active_stream.add_instruction(instruction)
4212    return instruction
4213
4214
4215def CMN(source_x, source_y):
4216    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4217    instruction = CompareInstruction('CMN', Operand(source_x), Operand(source_y), origin=origin)
4218    if peachpy.stream.active_stream is not None:
4219        peachpy.stream.active_stream.add_instruction(instruction)
4220    return instruction
4221
4222
4223def CMNEQ(source_x, source_y):
4224    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4225    instruction = CompareInstruction('CMNEQ', Operand(source_x), Operand(source_y), origin=origin)
4226    if peachpy.stream.active_stream is not None:
4227        peachpy.stream.active_stream.add_instruction(instruction)
4228    return instruction
4229
4230
4231def CMNNE(source_x, source_y):
4232    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4233    instruction = CompareInstruction('CMNNE', Operand(source_x), Operand(source_y), origin=origin)
4234    if peachpy.stream.active_stream is not None:
4235        peachpy.stream.active_stream.add_instruction(instruction)
4236    return instruction
4237
4238
4239def CMNCS(source_x, source_y):
4240    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4241    instruction = CompareInstruction('CMNCS', Operand(source_x), Operand(source_y), origin=origin)
4242    if peachpy.stream.active_stream is not None:
4243        peachpy.stream.active_stream.add_instruction(instruction)
4244    return instruction
4245
4246
4247def CMNHS(source_x, source_y):
4248    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4249    instruction = CompareInstruction('CMNHS', Operand(source_x), Operand(source_y), origin=origin)
4250    if peachpy.stream.active_stream is not None:
4251        peachpy.stream.active_stream.add_instruction(instruction)
4252    return instruction
4253
4254
4255def CMNCC(source_x, source_y):
4256    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4257    instruction = CompareInstruction('CMNCC', Operand(source_x), Operand(source_y), origin=origin)
4258    if peachpy.stream.active_stream is not None:
4259        peachpy.stream.active_stream.add_instruction(instruction)
4260    return instruction
4261
4262
4263def CMNLO(source_x, source_y):
4264    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4265    instruction = CompareInstruction('CMNLO', Operand(source_x), Operand(source_y), origin=origin)
4266    if peachpy.stream.active_stream is not None:
4267        peachpy.stream.active_stream.add_instruction(instruction)
4268    return instruction
4269
4270
4271def CMNMI(source_x, source_y):
4272    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4273    instruction = CompareInstruction('CMNMI', Operand(source_x), Operand(source_y), origin=origin)
4274    if peachpy.stream.active_stream is not None:
4275        peachpy.stream.active_stream.add_instruction(instruction)
4276    return instruction
4277
4278
4279def CMNPL(source_x, source_y):
4280    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4281    instruction = CompareInstruction('CMNPL', Operand(source_x), Operand(source_y), origin=origin)
4282    if peachpy.stream.active_stream is not None:
4283        peachpy.stream.active_stream.add_instruction(instruction)
4284    return instruction
4285
4286
4287def CMNVS(source_x, source_y):
4288    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4289    instruction = CompareInstruction('CMNVS', Operand(source_x), Operand(source_y), origin=origin)
4290    if peachpy.stream.active_stream is not None:
4291        peachpy.stream.active_stream.add_instruction(instruction)
4292    return instruction
4293
4294
4295def CMNVC(source_x, source_y):
4296    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4297    instruction = CompareInstruction('CMNVC', Operand(source_x), Operand(source_y), origin=origin)
4298    if peachpy.stream.active_stream is not None:
4299        peachpy.stream.active_stream.add_instruction(instruction)
4300    return instruction
4301
4302
4303def CMNHI(source_x, source_y):
4304    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4305    instruction = CompareInstruction('CMNHI', Operand(source_x), Operand(source_y), origin=origin)
4306    if peachpy.stream.active_stream is not None:
4307        peachpy.stream.active_stream.add_instruction(instruction)
4308    return instruction
4309
4310
4311def CMNLS(source_x, source_y):
4312    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4313    instruction = CompareInstruction('CMNLS', Operand(source_x), Operand(source_y), origin=origin)
4314    if peachpy.stream.active_stream is not None:
4315        peachpy.stream.active_stream.add_instruction(instruction)
4316    return instruction
4317
4318
4319def CMNGE(source_x, source_y):
4320    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4321    instruction = CompareInstruction('CMNGE', Operand(source_x), Operand(source_y), origin=origin)
4322    if peachpy.stream.active_stream is not None:
4323        peachpy.stream.active_stream.add_instruction(instruction)
4324    return instruction
4325
4326
4327def CMNLT(source_x, source_y):
4328    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4329    instruction = CompareInstruction('CMNLT', Operand(source_x), Operand(source_y), origin=origin)
4330    if peachpy.stream.active_stream is not None:
4331        peachpy.stream.active_stream.add_instruction(instruction)
4332    return instruction
4333
4334
4335def CMNGT(source_x, source_y):
4336    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4337    instruction = CompareInstruction('CMNGT', Operand(source_x), Operand(source_y), origin=origin)
4338    if peachpy.stream.active_stream is not None:
4339        peachpy.stream.active_stream.add_instruction(instruction)
4340    return instruction
4341
4342
4343def CMNLE(source_x, source_y):
4344    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4345    instruction = CompareInstruction('CMNLE', Operand(source_x), Operand(source_y), origin=origin)
4346    if peachpy.stream.active_stream is not None:
4347        peachpy.stream.active_stream.add_instruction(instruction)
4348    return instruction
4349
4350
4351def TST(source_x, source_y):
4352    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4353    instruction = CompareInstruction('TST', Operand(source_x), Operand(source_y), origin=origin)
4354    if peachpy.stream.active_stream is not None:
4355        peachpy.stream.active_stream.add_instruction(instruction)
4356    return instruction
4357
4358
4359def TSTEQ(source_x, source_y):
4360    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4361    instruction = CompareInstruction('TSTEQ', Operand(source_x), Operand(source_y), origin=origin)
4362    if peachpy.stream.active_stream is not None:
4363        peachpy.stream.active_stream.add_instruction(instruction)
4364    return instruction
4365
4366
4367def TSTNE(source_x, source_y):
4368    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4369    instruction = CompareInstruction('TSTNE', Operand(source_x), Operand(source_y), origin=origin)
4370    if peachpy.stream.active_stream is not None:
4371        peachpy.stream.active_stream.add_instruction(instruction)
4372    return instruction
4373
4374
4375def TSTCS(source_x, source_y):
4376    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4377    instruction = CompareInstruction('TSTCS', Operand(source_x), Operand(source_y), origin=origin)
4378    if peachpy.stream.active_stream is not None:
4379        peachpy.stream.active_stream.add_instruction(instruction)
4380    return instruction
4381
4382
4383def TSTHS(source_x, source_y):
4384    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4385    instruction = CompareInstruction('TSTHS', Operand(source_x), Operand(source_y), origin=origin)
4386    if peachpy.stream.active_stream is not None:
4387        peachpy.stream.active_stream.add_instruction(instruction)
4388    return instruction
4389
4390
4391def TSTCC(source_x, source_y):
4392    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4393    instruction = CompareInstruction('TSTCC', Operand(source_x), Operand(source_y), origin=origin)
4394    if peachpy.stream.active_stream is not None:
4395        peachpy.stream.active_stream.add_instruction(instruction)
4396    return instruction
4397
4398
4399def TSTLO(source_x, source_y):
4400    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4401    instruction = CompareInstruction('TSTLO', Operand(source_x), Operand(source_y), origin=origin)
4402    if peachpy.stream.active_stream is not None:
4403        peachpy.stream.active_stream.add_instruction(instruction)
4404    return instruction
4405
4406
4407def TSTMI(source_x, source_y):
4408    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4409    instruction = CompareInstruction('TSTMI', Operand(source_x), Operand(source_y), origin=origin)
4410    if peachpy.stream.active_stream is not None:
4411        peachpy.stream.active_stream.add_instruction(instruction)
4412    return instruction
4413
4414
4415def TSTPL(source_x, source_y):
4416    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4417    instruction = CompareInstruction('TSTPL', Operand(source_x), Operand(source_y), origin=origin)
4418    if peachpy.stream.active_stream is not None:
4419        peachpy.stream.active_stream.add_instruction(instruction)
4420    return instruction
4421
4422
4423def TSTVS(source_x, source_y):
4424    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4425    instruction = CompareInstruction('TSTVS', Operand(source_x), Operand(source_y), origin=origin)
4426    if peachpy.stream.active_stream is not None:
4427        peachpy.stream.active_stream.add_instruction(instruction)
4428    return instruction
4429
4430
4431def TSTVC(source_x, source_y):
4432    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4433    instruction = CompareInstruction('TSTVC', Operand(source_x), Operand(source_y), origin=origin)
4434    if peachpy.stream.active_stream is not None:
4435        peachpy.stream.active_stream.add_instruction(instruction)
4436    return instruction
4437
4438
4439def TSTHI(source_x, source_y):
4440    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4441    instruction = CompareInstruction('TSTHI', Operand(source_x), Operand(source_y), origin=origin)
4442    if peachpy.stream.active_stream is not None:
4443        peachpy.stream.active_stream.add_instruction(instruction)
4444    return instruction
4445
4446
4447def TSTLS(source_x, source_y):
4448    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4449    instruction = CompareInstruction('TSTLS', Operand(source_x), Operand(source_y), origin=origin)
4450    if peachpy.stream.active_stream is not None:
4451        peachpy.stream.active_stream.add_instruction(instruction)
4452    return instruction
4453
4454
4455def TSTGE(source_x, source_y):
4456    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4457    instruction = CompareInstruction('TSTGE', Operand(source_x), Operand(source_y), origin=origin)
4458    if peachpy.stream.active_stream is not None:
4459        peachpy.stream.active_stream.add_instruction(instruction)
4460    return instruction
4461
4462
4463def TSTLT(source_x, source_y):
4464    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4465    instruction = CompareInstruction('TSTLT', Operand(source_x), Operand(source_y), origin=origin)
4466    if peachpy.stream.active_stream is not None:
4467        peachpy.stream.active_stream.add_instruction(instruction)
4468    return instruction
4469
4470
4471def TSTGT(source_x, source_y):
4472    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4473    instruction = CompareInstruction('TSTGT', Operand(source_x), Operand(source_y), origin=origin)
4474    if peachpy.stream.active_stream is not None:
4475        peachpy.stream.active_stream.add_instruction(instruction)
4476    return instruction
4477
4478
4479def TSTLE(source_x, source_y):
4480    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4481    instruction = CompareInstruction('TSTLE', Operand(source_x), Operand(source_y), origin=origin)
4482    if peachpy.stream.active_stream is not None:
4483        peachpy.stream.active_stream.add_instruction(instruction)
4484    return instruction
4485
4486
4487def TEQ(source_x, source_y):
4488    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4489    instruction = CompareInstruction('TEQ', Operand(source_x), Operand(source_y), origin=origin)
4490    if peachpy.stream.active_stream is not None:
4491        peachpy.stream.active_stream.add_instruction(instruction)
4492    return instruction
4493
4494
4495def TEQEQ(source_x, source_y):
4496    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4497    instruction = CompareInstruction('TEQEQ', Operand(source_x), Operand(source_y), origin=origin)
4498    if peachpy.stream.active_stream is not None:
4499        peachpy.stream.active_stream.add_instruction(instruction)
4500    return instruction
4501
4502
4503def TEQNE(source_x, source_y):
4504    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4505    instruction = CompareInstruction('TEQNE', Operand(source_x), Operand(source_y), origin=origin)
4506    if peachpy.stream.active_stream is not None:
4507        peachpy.stream.active_stream.add_instruction(instruction)
4508    return instruction
4509
4510
4511def TEQCS(source_x, source_y):
4512    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4513    instruction = CompareInstruction('TEQCS', Operand(source_x), Operand(source_y), origin=origin)
4514    if peachpy.stream.active_stream is not None:
4515        peachpy.stream.active_stream.add_instruction(instruction)
4516    return instruction
4517
4518
4519def TEQHS(source_x, source_y):
4520    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4521    instruction = CompareInstruction('TEQHS', Operand(source_x), Operand(source_y), origin=origin)
4522    if peachpy.stream.active_stream is not None:
4523        peachpy.stream.active_stream.add_instruction(instruction)
4524    return instruction
4525
4526
4527def TEQCC(source_x, source_y):
4528    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4529    instruction = CompareInstruction('TEQCC', Operand(source_x), Operand(source_y), origin=origin)
4530    if peachpy.stream.active_stream is not None:
4531        peachpy.stream.active_stream.add_instruction(instruction)
4532    return instruction
4533
4534
4535def TEQLO(source_x, source_y):
4536    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4537    instruction = CompareInstruction('TEQLO', Operand(source_x), Operand(source_y), origin=origin)
4538    if peachpy.stream.active_stream is not None:
4539        peachpy.stream.active_stream.add_instruction(instruction)
4540    return instruction
4541
4542
4543def TEQMI(source_x, source_y):
4544    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4545    instruction = CompareInstruction('TEQMI', Operand(source_x), Operand(source_y), origin=origin)
4546    if peachpy.stream.active_stream is not None:
4547        peachpy.stream.active_stream.add_instruction(instruction)
4548    return instruction
4549
4550
4551def TEQPL(source_x, source_y):
4552    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4553    instruction = CompareInstruction('TEQPL', Operand(source_x), Operand(source_y), origin=origin)
4554    if peachpy.stream.active_stream is not None:
4555        peachpy.stream.active_stream.add_instruction(instruction)
4556    return instruction
4557
4558
4559def TEQVS(source_x, source_y):
4560    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4561    instruction = CompareInstruction('TEQVS', Operand(source_x), Operand(source_y), origin=origin)
4562    if peachpy.stream.active_stream is not None:
4563        peachpy.stream.active_stream.add_instruction(instruction)
4564    return instruction
4565
4566
4567def TEQVC(source_x, source_y):
4568    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4569    instruction = CompareInstruction('TEQVC', Operand(source_x), Operand(source_y), origin=origin)
4570    if peachpy.stream.active_stream is not None:
4571        peachpy.stream.active_stream.add_instruction(instruction)
4572    return instruction
4573
4574
4575def TEQHI(source_x, source_y):
4576    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4577    instruction = CompareInstruction('TEQHI', Operand(source_x), Operand(source_y), origin=origin)
4578    if peachpy.stream.active_stream is not None:
4579        peachpy.stream.active_stream.add_instruction(instruction)
4580    return instruction
4581
4582
4583def TEQLS(source_x, source_y):
4584    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4585    instruction = CompareInstruction('TEQLS', Operand(source_x), Operand(source_y), origin=origin)
4586    if peachpy.stream.active_stream is not None:
4587        peachpy.stream.active_stream.add_instruction(instruction)
4588    return instruction
4589
4590
4591def TEQGE(source_x, source_y):
4592    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4593    instruction = CompareInstruction('TEQGE', Operand(source_x), Operand(source_y), origin=origin)
4594    if peachpy.stream.active_stream is not None:
4595        peachpy.stream.active_stream.add_instruction(instruction)
4596    return instruction
4597
4598
4599def TEQLT(source_x, source_y):
4600    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4601    instruction = CompareInstruction('TEQLT', Operand(source_x), Operand(source_y), origin=origin)
4602    if peachpy.stream.active_stream is not None:
4603        peachpy.stream.active_stream.add_instruction(instruction)
4604    return instruction
4605
4606
4607def TEQGT(source_x, source_y):
4608    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4609    instruction = CompareInstruction('TEQGT', Operand(source_x), Operand(source_y), origin=origin)
4610    if peachpy.stream.active_stream is not None:
4611        peachpy.stream.active_stream.add_instruction(instruction)
4612    return instruction
4613
4614
4615def TEQLE(source_x, source_y):
4616    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4617    instruction = CompareInstruction('TEQLE', Operand(source_x), Operand(source_y), origin=origin)
4618    if peachpy.stream.active_stream is not None:
4619        peachpy.stream.active_stream.add_instruction(instruction)
4620    return instruction
4621
4622
4623def MOV(destination, source):
4624    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4625    instruction = MovInstruction('MOV', Operand(destination), Operand(source), origin=origin)
4626    if peachpy.stream.active_stream is not None:
4627        peachpy.stream.active_stream.add_instruction(instruction)
4628    return instruction
4629
4630
4631def MOVEQ(destination, source):
4632    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4633    instruction = MovInstruction('MOVEQ', Operand(destination), Operand(source), origin=origin)
4634    if peachpy.stream.active_stream is not None:
4635        peachpy.stream.active_stream.add_instruction(instruction)
4636    return instruction
4637
4638
4639def MOVNE(destination, source):
4640    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4641    instruction = MovInstruction('MOVNE', Operand(destination), Operand(source), origin=origin)
4642    if peachpy.stream.active_stream is not None:
4643        peachpy.stream.active_stream.add_instruction(instruction)
4644    return instruction
4645
4646
4647def MOVCS(destination, source):
4648    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4649    instruction = MovInstruction('MOVCS', Operand(destination), Operand(source), origin=origin)
4650    if peachpy.stream.active_stream is not None:
4651        peachpy.stream.active_stream.add_instruction(instruction)
4652    return instruction
4653
4654
4655def MOVHS(destination, source):
4656    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4657    instruction = MovInstruction('MOVHS', Operand(destination), Operand(source), origin=origin)
4658    if peachpy.stream.active_stream is not None:
4659        peachpy.stream.active_stream.add_instruction(instruction)
4660    return instruction
4661
4662
4663def MOVCC(destination, source):
4664    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4665    instruction = MovInstruction('MOVCC', Operand(destination), Operand(source), origin=origin)
4666    if peachpy.stream.active_stream is not None:
4667        peachpy.stream.active_stream.add_instruction(instruction)
4668    return instruction
4669
4670
4671def MOVLO(destination, source):
4672    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4673    instruction = MovInstruction('MOVLO', Operand(destination), Operand(source), origin=origin)
4674    if peachpy.stream.active_stream is not None:
4675        peachpy.stream.active_stream.add_instruction(instruction)
4676    return instruction
4677
4678
4679def MOVMI(destination, source):
4680    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4681    instruction = MovInstruction('MOVMI', Operand(destination), Operand(source), origin=origin)
4682    if peachpy.stream.active_stream is not None:
4683        peachpy.stream.active_stream.add_instruction(instruction)
4684    return instruction
4685
4686
4687def MOVPL(destination, source):
4688    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4689    instruction = MovInstruction('MOVPL', Operand(destination), Operand(source), origin=origin)
4690    if peachpy.stream.active_stream is not None:
4691        peachpy.stream.active_stream.add_instruction(instruction)
4692    return instruction
4693
4694
4695def MOVVS(destination, source):
4696    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4697    instruction = MovInstruction('MOVVS', Operand(destination), Operand(source), origin=origin)
4698    if peachpy.stream.active_stream is not None:
4699        peachpy.stream.active_stream.add_instruction(instruction)
4700    return instruction
4701
4702
4703def MOVVC(destination, source):
4704    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4705    instruction = MovInstruction('MOVVC', Operand(destination), Operand(source), origin=origin)
4706    if peachpy.stream.active_stream is not None:
4707        peachpy.stream.active_stream.add_instruction(instruction)
4708    return instruction
4709
4710
4711def MOVHI(destination, source):
4712    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4713    instruction = MovInstruction('MOVHI', Operand(destination), Operand(source), origin=origin)
4714    if peachpy.stream.active_stream is not None:
4715        peachpy.stream.active_stream.add_instruction(instruction)
4716    return instruction
4717
4718
4719def MOVLS(destination, source):
4720    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4721    instruction = MovInstruction('MOVLS', Operand(destination), Operand(source), origin=origin)
4722    if peachpy.stream.active_stream is not None:
4723        peachpy.stream.active_stream.add_instruction(instruction)
4724    return instruction
4725
4726
4727def MOVGE(destination, source):
4728    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4729    instruction = MovInstruction('MOVGE', Operand(destination), Operand(source), origin=origin)
4730    if peachpy.stream.active_stream is not None:
4731        peachpy.stream.active_stream.add_instruction(instruction)
4732    return instruction
4733
4734
4735def MOVLT(destination, source):
4736    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4737    instruction = MovInstruction('MOVLT', Operand(destination), Operand(source), origin=origin)
4738    if peachpy.stream.active_stream is not None:
4739        peachpy.stream.active_stream.add_instruction(instruction)
4740    return instruction
4741
4742
4743def MOVGT(destination, source):
4744    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4745    instruction = MovInstruction('MOVGT', Operand(destination), Operand(source), origin=origin)
4746    if peachpy.stream.active_stream is not None:
4747        peachpy.stream.active_stream.add_instruction(instruction)
4748    return instruction
4749
4750
4751def MOVLE(destination, source):
4752    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4753    instruction = MovInstruction('MOVLE', Operand(destination), Operand(source), origin=origin)
4754    if peachpy.stream.active_stream is not None:
4755        peachpy.stream.active_stream.add_instruction(instruction)
4756    return instruction
4757
4758
4759def MOVS(destination, source):
4760    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4761    instruction = MovInstruction('MOVS', Operand(destination), Operand(source), origin=origin)
4762    if peachpy.stream.active_stream is not None:
4763        peachpy.stream.active_stream.add_instruction(instruction)
4764    return instruction
4765
4766
4767def MOVSEQ(destination, source):
4768    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4769    instruction = MovInstruction('MOVSEQ', Operand(destination), Operand(source), origin=origin)
4770    if peachpy.stream.active_stream is not None:
4771        peachpy.stream.active_stream.add_instruction(instruction)
4772    return instruction
4773
4774
4775def MOVSNE(destination, source):
4776    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4777    instruction = MovInstruction('MOVSNE', Operand(destination), Operand(source), origin=origin)
4778    if peachpy.stream.active_stream is not None:
4779        peachpy.stream.active_stream.add_instruction(instruction)
4780    return instruction
4781
4782
4783def MOVSCS(destination, source):
4784    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4785    instruction = MovInstruction('MOVSCS', Operand(destination), Operand(source), origin=origin)
4786    if peachpy.stream.active_stream is not None:
4787        peachpy.stream.active_stream.add_instruction(instruction)
4788    return instruction
4789
4790
4791def MOVSHS(destination, source):
4792    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4793    instruction = MovInstruction('MOVSHS', Operand(destination), Operand(source), origin=origin)
4794    if peachpy.stream.active_stream is not None:
4795        peachpy.stream.active_stream.add_instruction(instruction)
4796    return instruction
4797
4798
4799def MOVSCC(destination, source):
4800    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4801    instruction = MovInstruction('MOVSCC', Operand(destination), Operand(source), origin=origin)
4802    if peachpy.stream.active_stream is not None:
4803        peachpy.stream.active_stream.add_instruction(instruction)
4804    return instruction
4805
4806
4807def MOVSLO(destination, source):
4808    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4809    instruction = MovInstruction('MOVSLO', Operand(destination), Operand(source), origin=origin)
4810    if peachpy.stream.active_stream is not None:
4811        peachpy.stream.active_stream.add_instruction(instruction)
4812    return instruction
4813
4814
4815def MOVSMI(destination, source):
4816    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4817    instruction = MovInstruction('MOVSMI', Operand(destination), Operand(source), origin=origin)
4818    if peachpy.stream.active_stream is not None:
4819        peachpy.stream.active_stream.add_instruction(instruction)
4820    return instruction
4821
4822
4823def MOVSPL(destination, source):
4824    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4825    instruction = MovInstruction('MOVSPL', Operand(destination), Operand(source), origin=origin)
4826    if peachpy.stream.active_stream is not None:
4827        peachpy.stream.active_stream.add_instruction(instruction)
4828    return instruction
4829
4830
4831def MOVSVS(destination, source):
4832    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4833    instruction = MovInstruction('MOVSVS', Operand(destination), Operand(source), origin=origin)
4834    if peachpy.stream.active_stream is not None:
4835        peachpy.stream.active_stream.add_instruction(instruction)
4836    return instruction
4837
4838
4839def MOVSVC(destination, source):
4840    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4841    instruction = MovInstruction('MOVSVC', Operand(destination), Operand(source), origin=origin)
4842    if peachpy.stream.active_stream is not None:
4843        peachpy.stream.active_stream.add_instruction(instruction)
4844    return instruction
4845
4846
4847def MOVSHI(destination, source):
4848    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4849    instruction = MovInstruction('MOVSHI', Operand(destination), Operand(source), origin=origin)
4850    if peachpy.stream.active_stream is not None:
4851        peachpy.stream.active_stream.add_instruction(instruction)
4852    return instruction
4853
4854
4855def MOVSLS(destination, source):
4856    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4857    instruction = MovInstruction('MOVSLS', Operand(destination), Operand(source), origin=origin)
4858    if peachpy.stream.active_stream is not None:
4859        peachpy.stream.active_stream.add_instruction(instruction)
4860    return instruction
4861
4862
4863def MOVSGE(destination, source):
4864    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4865    instruction = MovInstruction('MOVSGE', Operand(destination), Operand(source), origin=origin)
4866    if peachpy.stream.active_stream is not None:
4867        peachpy.stream.active_stream.add_instruction(instruction)
4868    return instruction
4869
4870
4871def MOVSLT(destination, source):
4872    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4873    instruction = MovInstruction('MOVSLT', Operand(destination), Operand(source), origin=origin)
4874    if peachpy.stream.active_stream is not None:
4875        peachpy.stream.active_stream.add_instruction(instruction)
4876    return instruction
4877
4878
4879def MOVSGT(destination, source):
4880    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4881    instruction = MovInstruction('MOVSGT', Operand(destination), Operand(source), origin=origin)
4882    if peachpy.stream.active_stream is not None:
4883        peachpy.stream.active_stream.add_instruction(instruction)
4884    return instruction
4885
4886
4887def MOVSLE(destination, source):
4888    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4889    instruction = MovInstruction('MOVSLE', Operand(destination), Operand(source), origin=origin)
4890    if peachpy.stream.active_stream is not None:
4891        peachpy.stream.active_stream.add_instruction(instruction)
4892    return instruction
4893
4894
4895def PUSH(register_list):
4896    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4897    instruction = PushPopInstruction('PUSH', Operand(register_list), origin=origin)
4898    if peachpy.stream.active_stream is not None:
4899        peachpy.stream.active_stream.add_instruction(instruction)
4900    return instruction
4901
4902
4903def POP(register_list):
4904    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4905    instruction = PushPopInstruction('POP', Operand(register_list), origin=origin)
4906    if peachpy.stream.active_stream is not None:
4907        peachpy.stream.active_stream.add_instruction(instruction)
4908    return instruction
4909
4910
4911def LDR(register, address, increment=None):
4912    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4913    instruction = LoadStoreInstruction('LDR', Operand(register), Operand(address), Operand(increment), origin=origin)
4914    if peachpy.stream.active_stream is not None:
4915        peachpy.stream.active_stream.add_instruction(instruction)
4916    return instruction
4917
4918
4919def STR(register, address, increment=None):
4920    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4921    instruction = LoadStoreInstruction('STR', Operand(register), Operand(address), Operand(increment), origin=origin)
4922    if peachpy.stream.active_stream is not None:
4923        peachpy.stream.active_stream.add_instruction(instruction)
4924    return instruction
4925
4926
4927def LDRH(register, address, increment=None):
4928    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4929    instruction = LoadStoreInstruction('LDRH', Operand(register), Operand(address), Operand(increment), origin=origin)
4930    if peachpy.stream.active_stream is not None:
4931        peachpy.stream.active_stream.add_instruction(instruction)
4932    return instruction
4933
4934
4935def LDRSH(register, address, increment=None):
4936    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4937    instruction = LoadStoreInstruction('LDRSH', Operand(register), Operand(address), Operand(increment), origin=origin)
4938    if peachpy.stream.active_stream is not None:
4939        peachpy.stream.active_stream.add_instruction(instruction)
4940    return instruction
4941
4942
4943def STRH(register, address, increment=None):
4944    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4945    instruction = LoadStoreInstruction('STRH', Operand(register), Operand(address), Operand(increment), origin=origin)
4946    if peachpy.stream.active_stream is not None:
4947        peachpy.stream.active_stream.add_instruction(instruction)
4948    return instruction
4949
4950
4951def LDRB(register, address, increment=None):
4952    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4953    instruction = LoadStoreInstruction('LDRB', Operand(register), Operand(address), Operand(increment), origin=origin)
4954    if peachpy.stream.active_stream is not None:
4955        peachpy.stream.active_stream.add_instruction(instruction)
4956    return instruction
4957
4958
4959def LDRSB(register, address, increment=None):
4960    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4961    instruction = LoadStoreInstruction('LDRSB', Operand(register), Operand(address), Operand(increment), origin=origin)
4962    if peachpy.stream.active_stream is not None:
4963        peachpy.stream.active_stream.add_instruction(instruction)
4964    return instruction
4965
4966
4967def STRB(register, address, increment=None):
4968    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4969    instruction = LoadStoreInstruction('STRB', Operand(register), Operand(address), Operand(increment), origin=origin)
4970    if peachpy.stream.active_stream is not None:
4971        peachpy.stream.active_stream.add_instruction(instruction)
4972    return instruction
4973
4974
4975def B(destination):
4976    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4977    instruction = BranchInstruction('B', Operand(destination), origin=origin)
4978    if peachpy.stream.active_stream is not None:
4979        peachpy.stream.active_stream.add_instruction(instruction)
4980    return instruction
4981
4982
4983def BEQ(destination):
4984    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4985    instruction = BranchInstruction('BEQ', Operand(destination), origin=origin)
4986    if peachpy.stream.active_stream is not None:
4987        peachpy.stream.active_stream.add_instruction(instruction)
4988    return instruction
4989
4990
4991def BNE(destination):
4992    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
4993    instruction = BranchInstruction('BNE', Operand(destination), origin=origin)
4994    if peachpy.stream.active_stream is not None:
4995        peachpy.stream.active_stream.add_instruction(instruction)
4996    return instruction
4997
4998
4999def BCS(destination):
5000    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5001    instruction = BranchInstruction('BCS', Operand(destination), origin=origin)
5002    if peachpy.stream.active_stream is not None:
5003        peachpy.stream.active_stream.add_instruction(instruction)
5004    return instruction
5005
5006
5007def BHS(destination):
5008    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5009    instruction = BranchInstruction('BHS', Operand(destination), origin=origin)
5010    if peachpy.stream.active_stream is not None:
5011        peachpy.stream.active_stream.add_instruction(instruction)
5012    return instruction
5013
5014
5015def BCC(destination):
5016    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5017    instruction = BranchInstruction('BCC', Operand(destination), origin=origin)
5018    if peachpy.stream.active_stream is not None:
5019        peachpy.stream.active_stream.add_instruction(instruction)
5020    return instruction
5021
5022
5023def BLO(destination):
5024    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5025    instruction = BranchInstruction('BLO', Operand(destination), origin=origin)
5026    if peachpy.stream.active_stream is not None:
5027        peachpy.stream.active_stream.add_instruction(instruction)
5028    return instruction
5029
5030
5031def BMI(destination):
5032    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5033    instruction = BranchInstruction('BMI', Operand(destination), origin=origin)
5034    if peachpy.stream.active_stream is not None:
5035        peachpy.stream.active_stream.add_instruction(instruction)
5036    return instruction
5037
5038
5039def BPL(destination):
5040    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5041    instruction = BranchInstruction('BPL', Operand(destination), origin=origin)
5042    if peachpy.stream.active_stream is not None:
5043        peachpy.stream.active_stream.add_instruction(instruction)
5044    return instruction
5045
5046
5047def BVS(destination):
5048    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5049    instruction = BranchInstruction('BVS', Operand(destination), origin=origin)
5050    if peachpy.stream.active_stream is not None:
5051        peachpy.stream.active_stream.add_instruction(instruction)
5052    return instruction
5053
5054
5055def BVC(destination):
5056    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5057    instruction = BranchInstruction('BVC', Operand(destination), origin=origin)
5058    if peachpy.stream.active_stream is not None:
5059        peachpy.stream.active_stream.add_instruction(instruction)
5060    return instruction
5061
5062
5063def BHI(destination):
5064    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5065    instruction = BranchInstruction('BHI', Operand(destination), origin=origin)
5066    if peachpy.stream.active_stream is not None:
5067        peachpy.stream.active_stream.add_instruction(instruction)
5068    return instruction
5069
5070
5071def BLS(destination):
5072    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5073    instruction = BranchInstruction('BLS', Operand(destination), origin=origin)
5074    if peachpy.stream.active_stream is not None:
5075        peachpy.stream.active_stream.add_instruction(instruction)
5076    return instruction
5077
5078
5079def BGE(destination):
5080    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5081    instruction = BranchInstruction('BGE', Operand(destination), origin=origin)
5082    if peachpy.stream.active_stream is not None:
5083        peachpy.stream.active_stream.add_instruction(instruction)
5084    return instruction
5085
5086
5087def BLT(destination):
5088    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5089    instruction = BranchInstruction('BLT', Operand(destination), origin=origin)
5090    if peachpy.stream.active_stream is not None:
5091        peachpy.stream.active_stream.add_instruction(instruction)
5092    return instruction
5093
5094
5095def BGT(destination):
5096    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5097    instruction = BranchInstruction('BGT', Operand(destination), origin=origin)
5098    if peachpy.stream.active_stream is not None:
5099        peachpy.stream.active_stream.add_instruction(instruction)
5100    return instruction
5101
5102
5103def BLE(destination):
5104    origin = inspect.stack() if peachpy.arm.function.active_function.collect_origin else None
5105    instruction = BranchInstruction('BLE', Operand(destination), origin=origin)
5106    if peachpy.stream.active_stream is not None:
5107        peachpy.stream.active_stream.add_instruction(instruction)
5108    return instruction
5109
5110
5111