id large_stringlengths 17 17 | instruction large_stringlengths 149 154 | code large_stringlengths 195 214 | unit_test large_stringlengths 81 90 |
|---|---|---|---|
py_logic_00001201 | Write a Python function `process_pipeline_v1201` that evaluates `value_b` against boundary `41` using relational operator `>`, returning mutated state. | def process_pipeline_v1201(value_b, value_b):
state_result = 0
if value_b > 41:
state_result = (value_b + 25) * 5
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v1201(46, 10) == 355
assert process_pipeline_v1201(36, 20) == -5 |
py_logic_00001202 | Write a Python function `process_pipeline_v1202` that evaluates `value_b` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v1202(value_b, value_a):
state_result = 0
if value_b > 50:
state_result = (value_b + 24) * 5
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v1202(55, 10) == 395
assert process_pipeline_v1202(45, 20) == -4 |
py_logic_00001203 | Write a Python function `process_pipeline_v1203` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v1203(value_b, value_a):
state_result = 0
if value_b > 57:
state_result = (value_b + 21) * 5
else:
state_result = value_a - 21
return state_result | assert process_pipeline_v1203(62, 10) == 415
assert process_pipeline_v1203(52, 20) == -1 |
py_logic_00001204 | Write a Python function `process_pipeline_v1204` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1204(value_b, value_b):
state_result = 0
if value_b > 59:
state_result = (value_b + 17) * 4
else:
state_result = value_b - 17
return state_result | assert process_pipeline_v1204(64, 10) == 324
assert process_pipeline_v1204(54, 20) == 3 |
py_logic_00001205 | Write a Python function `process_pipeline_v1205` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1205(value_b, state_flag):
state_result = 0
if value_b > 59:
state_result = (value_b + 12) * 4
else:
state_result = state_flag - 12
return state_result | assert process_pipeline_v1205(64, 10) == 304
assert process_pipeline_v1205(54, 20) == 8 |
py_logic_00001206 | Write a Python function `process_pipeline_v1206` that evaluates `value_b` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v1206(value_b, state_flag):
state_result = 0
if value_b > 54:
state_result = (value_b + 6) * 4
else:
state_result = state_flag - 6
return state_result | assert process_pipeline_v1206(59, 10) == 260
assert process_pipeline_v1206(49, 20) == 14 |
py_logic_00001207 | Write a Python function `process_pipeline_v1207` that evaluates `value_b` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v1207(value_b, state_flag):
state_result = 0
if value_b > 47:
state_result = (value_b + 1) * 3
else:
state_result = state_flag - 1
return state_result | assert process_pipeline_v1207(52, 10) == 159
assert process_pipeline_v1207(42, 20) == 19 |
py_logic_00001208 | Write a Python function `process_pipeline_v1208` that evaluates `value_b` against boundary `36` using relational operator `>`, returning mutated state. | def process_pipeline_v1208(value_b, state_flag):
state_result = 0
if value_b > 36:
state_result = (value_b + 8) * 3
else:
state_result = state_flag - 8
return state_result | assert process_pipeline_v1208(41, 10) == 147
assert process_pipeline_v1208(31, 20) == 12 |
py_logic_00001209 | Write a Python function `process_pipeline_v1209` that evaluates `value_b` against boundary `24` using relational operator `>`, returning mutated state. | def process_pipeline_v1209(value_b, state_flag):
state_result = 0
if value_b > 24:
state_result = (value_b + 13) * 2
else:
state_result = state_flag - 13
return state_result | assert process_pipeline_v1209(29, 10) == 84
assert process_pipeline_v1209(19, 20) == 7 |
py_logic_00001210 | Write a Python function `process_pipeline_v1210` that evaluates `value_b` against boundary `11` using relational operator `>`, returning mutated state. | def process_pipeline_v1210(value_b, state_flag):
state_result = 0
if value_b > 11:
state_result = (value_b + 18) * 2
else:
state_result = state_flag - 18
return state_result | assert process_pipeline_v1210(16, 10) == 68
assert process_pipeline_v1210(6, 20) == 2 |
py_logic_00001211 | Write a Python function `process_pipeline_v1211` that evaluates `value_b` against boundary `22` using relational operator `>`, returning mutated state. | def process_pipeline_v1211(value_b, state_flag):
state_result = 0
if value_b > 22:
state_result = (value_b + 22) * 2
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v1211(27, 10) == 98
assert process_pipeline_v1211(17, 20) == -2 |
py_logic_00001212 | Write a Python function `process_pipeline_v1212` that evaluates `value_b` against boundary `34` using relational operator `>`, returning mutated state. | def process_pipeline_v1212(value_b, state_flag):
state_result = 0
if value_b > 34:
state_result = (value_b + 25) * 3
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1212(39, 10) == 192
assert process_pipeline_v1212(29, 20) == -5 |
py_logic_00001213 | Write a Python function `process_pipeline_v1213` that evaluates `value_b` against boundary `45` using relational operator `>`, returning mutated state. | def process_pipeline_v1213(value_b, state_flag):
state_result = 0
if value_b > 45:
state_result = (value_b + 25) * 3
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1213(50, 10) == 225
assert process_pipeline_v1213(40, 20) == -5 |
py_logic_00001214 | Write a Python function `process_pipeline_v1214` that evaluates `value_a` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v1214(value_a, state_flag):
state_result = 0
if value_a > 53:
state_result = (value_a + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1214(58, 10) == 332
assert process_pipeline_v1214(48, 20) == -5 |
py_logic_00001215 | Write a Python function `process_pipeline_v1215` that evaluates `value_a` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v1215(value_a, state_flag):
state_result = 0
if value_a > 58:
state_result = (value_a + 23) * 4
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v1215(63, 10) == 344
assert process_pipeline_v1215(53, 20) == -3 |
py_logic_00001216 | Write a Python function `process_pipeline_v1216` that evaluates `value_a` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1216(value_a, state_flag):
state_result = 0
if value_a > 59:
state_result = (value_a + 19) * 4
else:
state_result = state_flag - 19
return state_result | assert process_pipeline_v1216(64, 10) == 332
assert process_pipeline_v1216(54, 20) == 1 |
py_logic_00001217 | Write a Python function `process_pipeline_v1217` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v1217(value_b, state_flag):
state_result = 0
if value_b > 57:
state_result = (value_b + 14) * 5
else:
state_result = state_flag - 14
return state_result | assert process_pipeline_v1217(62, 10) == 380
assert process_pipeline_v1217(52, 20) == 6 |
py_logic_00001218 | Write a Python function `process_pipeline_v1218` that evaluates `value_b` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v1218(value_b, state_flag):
state_result = 0
if value_b > 52:
state_result = (value_b + 8) * 5
else:
state_result = state_flag - 8
return state_result | assert process_pipeline_v1218(57, 10) == 325
assert process_pipeline_v1218(47, 20) == 12 |
py_logic_00001219 | Write a Python function `process_pipeline_v1219` that evaluates `state_flag` against boundary `43` using relational operator `>`, returning mutated state. | def process_pipeline_v1219(state_flag, state_flag):
state_result = 0
if state_flag > 43:
state_result = (state_flag + 2) * 5
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v1219(48, 10) == 250
assert process_pipeline_v1219(38, 20) == 18 |
py_logic_00001220 | Write a Python function `process_pipeline_v1220` that evaluates `state_flag` against boundary `32` using relational operator `>`, returning mutated state. | def process_pipeline_v1220(state_flag, state_flag):
state_result = 0
if state_flag > 32:
state_result = (state_flag + 5) * 5
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v1220(37, 10) == 210
assert process_pipeline_v1220(27, 20) == 15 |
py_logic_00001221 | Write a Python function `process_pipeline_v1221` that evaluates `state_flag` against boundary `19` using relational operator `>`, returning mutated state. | def process_pipeline_v1221(state_flag, state_flag):
state_result = 0
if state_flag > 19:
state_result = (state_flag + 11) * 5
else:
state_result = state_flag - 11
return state_result | assert process_pipeline_v1221(24, 10) == 175
assert process_pipeline_v1221(14, 20) == 9 |
py_logic_00001222 | Write a Python function `process_pipeline_v1222` that evaluates `state_flag` against boundary `13` using relational operator `>`, returning mutated state. | def process_pipeline_v1222(state_flag, state_flag):
state_result = 0
if state_flag > 13:
state_result = (state_flag + 17) * 5
else:
state_result = state_flag - 17
return state_result | assert process_pipeline_v1222(18, 10) == 175
assert process_pipeline_v1222(8, 20) == 3 |
py_logic_00001223 | Write a Python function `process_pipeline_v1223` that evaluates `state_flag` against boundary `26` using relational operator `>`, returning mutated state. | def process_pipeline_v1223(state_flag, state_flag):
state_result = 0
if state_flag > 26:
state_result = (state_flag + 21) * 5
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v1223(31, 10) == 260
assert process_pipeline_v1223(21, 20) == -1 |
py_logic_00001224 | Write a Python function `process_pipeline_v1224` that evaluates `state_flag` against boundary `38` using relational operator `>`, returning mutated state. | def process_pipeline_v1224(state_flag, state_flag):
state_result = 0
if state_flag > 38:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v1224(43, 10) == 335
assert process_pipeline_v1224(33, 20) == -4 |
py_logic_00001225 | Write a Python function `process_pipeline_v1225` that evaluates `state_flag` against boundary `48` using relational operator `>`, returning mutated state. | def process_pipeline_v1225(state_flag, state_flag):
state_result = 0
if state_flag > 48:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1225(53, 10) == 390
assert process_pipeline_v1225(43, 20) == -5 |
py_logic_00001226 | Write a Python function `process_pipeline_v1226` that evaluates `state_flag` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v1226(state_flag, state_flag):
state_result = 0
if state_flag > 55:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1226(60, 10) == 425
assert process_pipeline_v1226(50, 20) == -5 |
py_logic_00001227 | Write a Python function `process_pipeline_v1227` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1227(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v1227(64, 10) == 440
assert process_pipeline_v1227(54, 20) == -4 |
py_logic_00001228 | Write a Python function `process_pipeline_v1228` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1228(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 20) * 4
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v1228(64, 10) == 336
assert process_pipeline_v1228(54, 20) == 0 |
py_logic_00001229 | Write a Python function `process_pipeline_v1229` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v1229(state_flag, state_flag):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 16) * 4
else:
state_result = state_flag - 16
return state_result | assert process_pipeline_v1229(61, 10) == 308
assert process_pipeline_v1229(51, 20) == 4 |
py_logic_00001230 | Write a Python function `process_pipeline_v1230` that evaluates `state_flag` against boundary `49` using relational operator `>`, returning mutated state. | def process_pipeline_v1230(state_flag, state_flag):
state_result = 0
if state_flag > 49:
state_result = (state_flag + 11) * 3
else:
state_result = state_flag - 11
return state_result | assert process_pipeline_v1230(54, 10) == 195
assert process_pipeline_v1230(44, 20) == 9 |
py_logic_00001231 | Write a Python function `process_pipeline_v1231` that evaluates `state_flag` against boundary `39` using relational operator `>`, returning mutated state. | def process_pipeline_v1231(state_flag, value_b):
state_result = 0
if state_flag > 39:
state_result = (state_flag + 4) * 3
else:
state_result = value_b - 4
return state_result | assert process_pipeline_v1231(44, 10) == 144
assert process_pipeline_v1231(34, 20) == 16 |
py_logic_00001232 | Write a Python function `process_pipeline_v1232` that evaluates `state_flag` against boundary `28` using relational operator `>`, returning mutated state. | def process_pipeline_v1232(state_flag, value_b):
state_result = 0
if state_flag > 28:
state_result = (state_flag + 3) * 2
else:
state_result = value_b - 3
return state_result | assert process_pipeline_v1232(33, 10) == 72
assert process_pipeline_v1232(23, 20) == 17 |
py_logic_00001233 | Write a Python function `process_pipeline_v1233` that evaluates `state_flag` against boundary `14` using relational operator `>`, returning mutated state. | def process_pipeline_v1233(state_flag, value_b):
state_result = 0
if state_flag > 14:
state_result = (state_flag + 9) * 2
else:
state_result = value_b - 9
return state_result | assert process_pipeline_v1233(19, 10) == 56
assert process_pipeline_v1233(9, 20) == 11 |
py_logic_00001234 | Write a Python function `process_pipeline_v1234` that evaluates `state_flag` against boundary `18` using relational operator `>`, returning mutated state. | def process_pipeline_v1234(state_flag, value_a):
state_result = 0
if state_flag > 18:
state_result = (state_flag + 15) * 2
else:
state_result = value_a - 15
return state_result | assert process_pipeline_v1234(23, 10) == 76
assert process_pipeline_v1234(13, 20) == 5 |
py_logic_00001235 | Write a Python function `process_pipeline_v1235` that evaluates `state_flag` against boundary `31` using relational operator `>`, returning mutated state. | def process_pipeline_v1235(state_flag, value_a):
state_result = 0
if state_flag > 31:
state_result = (state_flag + 19) * 2
else:
state_result = value_a - 19
return state_result | assert process_pipeline_v1235(36, 10) == 110
assert process_pipeline_v1235(26, 20) == 1 |
py_logic_00001236 | Write a Python function `process_pipeline_v1236` that evaluates `state_flag` against boundary `42` using relational operator `>`, returning mutated state. | def process_pipeline_v1236(state_flag, value_a):
state_result = 0
if state_flag > 42:
state_result = (state_flag + 23) * 3
else:
state_result = value_a - 23
return state_result | assert process_pipeline_v1236(47, 10) == 210
assert process_pipeline_v1236(37, 20) == -3 |
py_logic_00001237 | Write a Python function `process_pipeline_v1237` that evaluates `state_flag` against boundary `51` using relational operator `>`, returning mutated state. | def process_pipeline_v1237(state_flag, value_a):
state_result = 0
if state_flag > 51:
state_result = (state_flag + 25) * 3
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v1237(56, 10) == 243
assert process_pipeline_v1237(46, 20) == -5 |
py_logic_00001238 | Write a Python function `process_pipeline_v1238` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v1238(value_b, value_a):
state_result = 0
if value_b > 57:
state_result = (value_b + 25) * 4
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v1238(62, 10) == 348
assert process_pipeline_v1238(52, 20) == -5 |
py_logic_00001239 | Write a Python function `process_pipeline_v1239` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1239(value_b, value_a):
state_result = 0
if value_b > 59:
state_result = (value_b + 24) * 4
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v1239(64, 10) == 352
assert process_pipeline_v1239(54, 20) == -4 |
py_logic_00001240 | Write a Python function `process_pipeline_v1240` that evaluates `value_b` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v1240(value_b, value_b):
state_result = 0
if value_b > 58:
state_result = (value_b + 22) * 5
else:
state_result = value_b - 22
return state_result | assert process_pipeline_v1240(63, 10) == 425
assert process_pipeline_v1240(53, 20) == -2 |
py_logic_00001241 | Write a Python function `process_pipeline_v1241` that evaluates `value_b` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v1241(value_b, value_b):
state_result = 0
if value_b > 54:
state_result = (value_b + 18) * 5
else:
state_result = value_b - 18
return state_result | assert process_pipeline_v1241(59, 10) == 385
assert process_pipeline_v1241(49, 20) == 2 |
py_logic_00001242 | Write a Python function `process_pipeline_v1242` that evaluates `value_b` against boundary `46` using relational operator `>`, returning mutated state. | def process_pipeline_v1242(value_b, value_b):
state_result = 0
if value_b > 46:
state_result = (value_b + 13) * 5
else:
state_result = value_b - 13
return state_result | assert process_pipeline_v1242(51, 10) == 320
assert process_pipeline_v1242(41, 20) == 7 |
py_logic_00001243 | Write a Python function `process_pipeline_v1243` that evaluates `state_flag` against boundary `35` using relational operator `>`, returning mutated state. | def process_pipeline_v1243(state_flag, value_b):
state_result = 0
if state_flag > 35:
state_result = (state_flag + 7) * 5
else:
state_result = value_b - 7
return state_result | assert process_pipeline_v1243(40, 10) == 235
assert process_pipeline_v1243(30, 20) == 13 |
py_logic_00001244 | Write a Python function `process_pipeline_v1244` that evaluates `state_flag` against boundary `23` using relational operator `>`, returning mutated state. | def process_pipeline_v1244(state_flag, value_b):
state_result = 0
if state_flag > 23:
state_result = (state_flag + 1) * 5
else:
state_result = value_b - 1
return state_result | assert process_pipeline_v1244(28, 10) == 145
assert process_pipeline_v1244(18, 20) == 19 |
py_logic_00001245 | Write a Python function `process_pipeline_v1245` that evaluates `state_flag` against boundary `10` using relational operator `>`, returning mutated state. | def process_pipeline_v1245(state_flag, value_a):
state_result = 0
if state_flag > 10:
state_result = (state_flag + 7) * 5
else:
state_result = value_a - 7
return state_result | assert process_pipeline_v1245(15, 10) == 110
assert process_pipeline_v1245(5, 20) == 13 |
py_logic_00001246 | Write a Python function `process_pipeline_v1246` that evaluates `state_flag` against boundary `23` using relational operator `>`, returning mutated state. | def process_pipeline_v1246(state_flag, value_a):
state_result = 0
if state_flag > 23:
state_result = (state_flag + 13) * 5
else:
state_result = value_a - 13
return state_result | assert process_pipeline_v1246(28, 10) == 205
assert process_pipeline_v1246(18, 20) == 7 |
py_logic_00001247 | Write a Python function `process_pipeline_v1247` that evaluates `state_flag` against boundary `35` using relational operator `>`, returning mutated state. | def process_pipeline_v1247(state_flag, value_a):
state_result = 0
if state_flag > 35:
state_result = (state_flag + 18) * 5
else:
state_result = value_a - 18
return state_result | assert process_pipeline_v1247(40, 10) == 290
assert process_pipeline_v1247(30, 20) == 2 |
py_logic_00001248 | Write a Python function `process_pipeline_v1248` that evaluates `state_flag` against boundary `46` using relational operator `>`, returning mutated state. | def process_pipeline_v1248(state_flag, value_a):
state_result = 0
if state_flag > 46:
state_result = (state_flag + 22) * 5
else:
state_result = value_a - 22
return state_result | assert process_pipeline_v1248(51, 10) == 365
assert process_pipeline_v1248(41, 20) == -2 |
py_logic_00001249 | Write a Python function `process_pipeline_v1249` that evaluates `value_b` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v1249(value_b, value_b):
state_result = 0
if value_b > 54:
state_result = (value_b + 24) * 5
else:
state_result = value_b - 24
return state_result | assert process_pipeline_v1249(59, 10) == 415
assert process_pipeline_v1249(49, 20) == -4 |
py_logic_00001250 | Write a Python function `process_pipeline_v1250` that evaluates `value_a` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v1250(value_a, value_b):
state_result = 0
if value_a > 58:
state_result = (value_a + 25) * 5
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v1250(63, 10) == 440
assert process_pipeline_v1250(53, 20) == -5 |
py_logic_00001251 | Write a Python function `process_pipeline_v1251` that evaluates `value_a` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1251(value_a, state_flag):
state_result = 0
if value_a > 59:
state_result = (value_a + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1251(64, 10) == 356
assert process_pipeline_v1251(54, 20) == -5 |
py_logic_00001252 | Write a Python function `process_pipeline_v1252` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v1252(value_b, state_flag):
state_result = 0
if value_b > 57:
state_result = (value_b + 23) * 4
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v1252(62, 10) == 340
assert process_pipeline_v1252(52, 20) == -3 |
py_logic_00001253 | Write a Python function `process_pipeline_v1253` that evaluates `state_flag` against boundary `51` using relational operator `>`, returning mutated state. | def process_pipeline_v1253(state_flag, state_flag):
state_result = 0
if state_flag > 51:
state_result = (state_flag + 19) * 3
else:
state_result = state_flag - 19
return state_result | assert process_pipeline_v1253(56, 10) == 225
assert process_pipeline_v1253(46, 20) == 1 |
py_logic_00001254 | Write a Python function `process_pipeline_v1254` that evaluates `state_flag` against boundary `42` using relational operator `>`, returning mutated state. | def process_pipeline_v1254(state_flag, state_flag):
state_result = 0
if state_flag > 42:
state_result = (state_flag + 15) * 3
else:
state_result = state_flag - 15
return state_result | assert process_pipeline_v1254(47, 10) == 186
assert process_pipeline_v1254(37, 20) == 5 |
py_logic_00001255 | Write a Python function `process_pipeline_v1255` that evaluates `state_flag` against boundary `31` using relational operator `>`, returning mutated state. | def process_pipeline_v1255(state_flag, state_flag):
state_result = 0
if state_flag > 31:
state_result = (state_flag + 9) * 2
else:
state_result = state_flag - 9
return state_result | assert process_pipeline_v1255(36, 10) == 90
assert process_pipeline_v1255(26, 20) == 11 |
py_logic_00001256 | Write a Python function `process_pipeline_v1256` that evaluates `state_flag` against boundary `18` using relational operator `>`, returning mutated state. | def process_pipeline_v1256(state_flag, state_flag):
state_result = 0
if state_flag > 18:
state_result = (state_flag + 3) * 2
else:
state_result = state_flag - 3
return state_result | assert process_pipeline_v1256(23, 10) == 52
assert process_pipeline_v1256(13, 20) == 17 |
py_logic_00001257 | Write a Python function `process_pipeline_v1257` that evaluates `state_flag` against boundary `14` using relational operator `>`, returning mutated state. | def process_pipeline_v1257(state_flag, value_b):
state_result = 0
if state_flag > 14:
state_result = (state_flag + 4) * 2
else:
state_result = value_b - 4
return state_result | assert process_pipeline_v1257(19, 10) == 46
assert process_pipeline_v1257(9, 20) == 16 |
py_logic_00001258 | Write a Python function `process_pipeline_v1258` that evaluates `state_flag` against boundary `27` using relational operator `>`, returning mutated state. | def process_pipeline_v1258(state_flag, value_b):
state_result = 0
if state_flag > 27:
state_result = (state_flag + 10) * 2
else:
state_result = value_b - 10
return state_result | assert process_pipeline_v1258(32, 10) == 84
assert process_pipeline_v1258(22, 20) == 10 |
py_logic_00001259 | Write a Python function `process_pipeline_v1259` that evaluates `state_flag` against boundary `39` using relational operator `>`, returning mutated state. | def process_pipeline_v1259(state_flag, value_b):
state_result = 0
if state_flag > 39:
state_result = (state_flag + 16) * 3
else:
state_result = value_b - 16
return state_result | assert process_pipeline_v1259(44, 10) == 180
assert process_pipeline_v1259(34, 20) == 4 |
py_logic_00001260 | Write a Python function `process_pipeline_v1260` that evaluates `state_flag` against boundary `49` using relational operator `>`, returning mutated state. | def process_pipeline_v1260(state_flag, value_a):
state_result = 0
if state_flag > 49:
state_result = (state_flag + 20) * 3
else:
state_result = value_a - 20
return state_result | assert process_pipeline_v1260(54, 10) == 222
assert process_pipeline_v1260(44, 20) == 0 |
py_logic_00001261 | Write a Python function `process_pipeline_v1261` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v1261(state_flag, value_a):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 24) * 4
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v1261(61, 10) == 340
assert process_pipeline_v1261(51, 20) == -4 |
py_logic_00001262 | Write a Python function `process_pipeline_v1262` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1262(state_flag, value_b):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 25) * 4
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v1262(64, 10) == 356
assert process_pipeline_v1262(54, 20) == -5 |
py_logic_00001263 | Write a Python function `process_pipeline_v1263` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1263(state_flag, value_b):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 25) * 5
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v1263(64, 10) == 445
assert process_pipeline_v1263(54, 20) == -5 |
py_logic_00001264 | Write a Python function `process_pipeline_v1264` that evaluates `state_flag` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v1264(state_flag, state_flag):
state_result = 0
if state_flag > 55:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v1264(60, 10) == 420
assert process_pipeline_v1264(50, 20) == -4 |
py_logic_00001265 | Write a Python function `process_pipeline_v1265` that evaluates `state_flag` against boundary `48` using relational operator `>`, returning mutated state. | def process_pipeline_v1265(state_flag, state_flag):
state_result = 0
if state_flag > 48:
state_result = (state_flag + 21) * 5
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v1265(53, 10) == 370
assert process_pipeline_v1265(43, 20) == -1 |
py_logic_00001266 | Write a Python function `process_pipeline_v1266` that evaluates `state_flag` against boundary `38` using relational operator `>`, returning mutated state. | def process_pipeline_v1266(state_flag, state_flag):
state_result = 0
if state_flag > 38:
state_result = (state_flag + 17) * 5
else:
state_result = state_flag - 17
return state_result | assert process_pipeline_v1266(43, 10) == 300
assert process_pipeline_v1266(33, 20) == 3 |
py_logic_00001267 | Write a Python function `process_pipeline_v1267` that evaluates `state_flag` against boundary `26` using relational operator `>`, returning mutated state. | def process_pipeline_v1267(state_flag, state_flag):
state_result = 0
if state_flag > 26:
state_result = (state_flag + 11) * 5
else:
state_result = state_flag - 11
return state_result | assert process_pipeline_v1267(31, 10) == 210
assert process_pipeline_v1267(21, 20) == 9 |
py_logic_00001268 | Write a Python function `process_pipeline_v1268` that evaluates `state_flag` against boundary `13` using relational operator `>`, returning mutated state. | def process_pipeline_v1268(state_flag, state_flag):
state_result = 0
if state_flag > 13:
state_result = (state_flag + 5) * 5
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v1268(18, 10) == 115
assert process_pipeline_v1268(8, 20) == 15 |
py_logic_00001269 | Write a Python function `process_pipeline_v1269` that evaluates `state_flag` against boundary `19` using relational operator `>`, returning mutated state. | def process_pipeline_v1269(state_flag, state_flag):
state_result = 0
if state_flag > 19:
state_result = (state_flag + 2) * 5
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v1269(24, 10) == 130
assert process_pipeline_v1269(14, 20) == 18 |
py_logic_00001270 | Write a Python function `process_pipeline_v1270` that evaluates `state_flag` against boundary `32` using relational operator `>`, returning mutated state. | def process_pipeline_v1270(state_flag, state_flag):
state_result = 0
if state_flag > 32:
state_result = (state_flag + 8) * 5
else:
state_result = state_flag - 8
return state_result | assert process_pipeline_v1270(37, 10) == 225
assert process_pipeline_v1270(27, 20) == 12 |
py_logic_00001271 | Write a Python function `process_pipeline_v1271` that evaluates `state_flag` against boundary `43` using relational operator `>`, returning mutated state. | def process_pipeline_v1271(state_flag, state_flag):
state_result = 0
if state_flag > 43:
state_result = (state_flag + 14) * 5
else:
state_result = state_flag - 14
return state_result | assert process_pipeline_v1271(48, 10) == 310
assert process_pipeline_v1271(38, 20) == 6 |
py_logic_00001272 | Write a Python function `process_pipeline_v1272` that evaluates `state_flag` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v1272(state_flag, state_flag):
state_result = 0
if state_flag > 52:
state_result = (state_flag + 19) * 5
else:
state_result = state_flag - 19
return state_result | assert process_pipeline_v1272(57, 10) == 380
assert process_pipeline_v1272(47, 20) == 1 |
py_logic_00001273 | Write a Python function `process_pipeline_v1273` that evaluates `state_flag` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v1273(state_flag, state_flag):
state_result = 0
if state_flag > 57:
state_result = (state_flag + 22) * 5
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v1273(62, 10) == 420
assert process_pipeline_v1273(52, 20) == -2 |
py_logic_00001274 | Write a Python function `process_pipeline_v1274` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1274(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1274(64, 10) == 356
assert process_pipeline_v1274(54, 20) == -5 |
py_logic_00001275 | Write a Python function `process_pipeline_v1275` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v1275(state_flag, state_flag):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1275(63, 10) == 352
assert process_pipeline_v1275(53, 20) == -5 |
py_logic_00001276 | Write a Python function `process_pipeline_v1276` that evaluates `value_b` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v1276(value_b, state_flag):
state_result = 0
if value_b > 53:
state_result = (value_b + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v1276(58, 10) == 332
assert process_pipeline_v1276(48, 20) == -5 |
py_logic_00001277 | Write a Python function `process_pipeline_v1277` that evaluates `value_b` against boundary `45` using relational operator `>`, returning mutated state. | def process_pipeline_v1277(value_b, state_flag):
state_result = 0
if value_b > 45:
state_result = (value_b + 22) * 3
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v1277(50, 10) == 216
assert process_pipeline_v1277(40, 20) == -2 |
py_logic_00001278 | Write a Python function `process_pipeline_v1278` that evaluates `value_b` against boundary `34` using relational operator `>`, returning mutated state. | def process_pipeline_v1278(value_b, value_b):
state_result = 0
if value_b > 34:
state_result = (value_b + 18) * 3
else:
state_result = value_b - 18
return state_result | assert process_pipeline_v1278(39, 10) == 171
assert process_pipeline_v1278(29, 20) == 2 |
py_logic_00001279 | Write a Python function `process_pipeline_v1279` that evaluates `value_a` against boundary `22` using relational operator `>`, returning mutated state. | def process_pipeline_v1279(value_a, value_b):
state_result = 0
if value_a > 22:
state_result = (value_a + 13) * 2
else:
state_result = value_b - 13
return state_result | assert process_pipeline_v1279(27, 10) == 80
assert process_pipeline_v1279(17, 20) == 7 |
py_logic_00001280 | Write a Python function `process_pipeline_v1280` that evaluates `value_a` against boundary `11` using relational operator `>`, returning mutated state. | def process_pipeline_v1280(value_a, value_b):
state_result = 0
if value_a > 11:
state_result = (value_a + 8) * 2
else:
state_result = value_b - 8
return state_result | assert process_pipeline_v1280(16, 10) == 48
assert process_pipeline_v1280(6, 20) == 12 |
py_logic_00001281 | Write a Python function `process_pipeline_v1281` that evaluates `value_a` against boundary `24` using relational operator `>`, returning mutated state. | def process_pipeline_v1281(value_a, value_b):
state_result = 0
if value_a > 24:
state_result = (value_a + 1) * 2
else:
state_result = value_b - 1
return state_result | assert process_pipeline_v1281(29, 10) == 60
assert process_pipeline_v1281(19, 20) == 19 |
py_logic_00001282 | Write a Python function `process_pipeline_v1282` that evaluates `value_a` against boundary `36` using relational operator `>`, returning mutated state. | def process_pipeline_v1282(value_a, value_b):
state_result = 0
if value_a > 36:
state_result = (value_a + 6) * 3
else:
state_result = value_b - 6
return state_result | assert process_pipeline_v1282(41, 10) == 141
assert process_pipeline_v1282(31, 20) == 14 |
py_logic_00001283 | Write a Python function `process_pipeline_v1283` that evaluates `value_b` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v1283(value_b, value_b):
state_result = 0
if value_b > 47:
state_result = (value_b + 12) * 3
else:
state_result = value_b - 12
return state_result | assert process_pipeline_v1283(52, 10) == 192
assert process_pipeline_v1283(42, 20) == 8 |
py_logic_00001284 | Write a Python function `process_pipeline_v1284` that evaluates `value_b` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v1284(value_b, value_b):
state_result = 0
if value_b > 54:
state_result = (value_b + 17) * 4
else:
state_result = value_b - 17
return state_result | assert process_pipeline_v1284(59, 10) == 304
assert process_pipeline_v1284(49, 20) == 3 |
py_logic_00001285 | Write a Python function `process_pipeline_v1285` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1285(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 21) * 4
else:
state_result = value_a - 21
return state_result | assert process_pipeline_v1285(64, 10) == 340
assert process_pipeline_v1285(54, 20) == -1 |
py_logic_00001286 | Write a Python function `process_pipeline_v1286` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1286(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 24) * 4
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v1286(64, 10) == 352
assert process_pipeline_v1286(54, 20) == -4 |
py_logic_00001287 | Write a Python function `process_pipeline_v1287` that evaluates `state_flag` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v1287(state_flag, value_a):
state_result = 0
if state_flag > 57:
state_result = (state_flag + 25) * 5
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v1287(62, 10) == 435
assert process_pipeline_v1287(52, 20) == -5 |
py_logic_00001288 | Write a Python function `process_pipeline_v1288` that evaluates `state_flag` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v1288(state_flag, value_a):
state_result = 0
if state_flag > 50:
state_result = (state_flag + 25) * 5
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v1288(55, 10) == 400
assert process_pipeline_v1288(45, 20) == -5 |
py_logic_00001289 | Write a Python function `process_pipeline_v1289` that evaluates `state_flag` against boundary `41` using relational operator `>`, returning mutated state. | def process_pipeline_v1289(state_flag, value_a):
state_result = 0
if state_flag > 41:
state_result = (state_flag + 23) * 5
else:
state_result = value_a - 23
return state_result | assert process_pipeline_v1289(46, 10) == 345
assert process_pipeline_v1289(36, 20) == -3 |
py_logic_00001290 | Write a Python function `process_pipeline_v1290` that evaluates `state_flag` against boundary `30` using relational operator `>`, returning mutated state. | def process_pipeline_v1290(state_flag, value_b):
state_result = 0
if state_flag > 30:
state_result = (state_flag + 20) * 5
else:
state_result = value_b - 20
return state_result | assert process_pipeline_v1290(35, 10) == 275
assert process_pipeline_v1290(25, 20) == 0 |
py_logic_00001291 | Write a Python function `process_pipeline_v1291` that evaluates `state_flag` against boundary `17` using relational operator `>`, returning mutated state. | def process_pipeline_v1291(state_flag, state_flag):
state_result = 0
if state_flag > 17:
state_result = (state_flag + 15) * 5
else:
state_result = state_flag - 15
return state_result | assert process_pipeline_v1291(22, 10) == 185
assert process_pipeline_v1291(12, 20) == 5 |
py_logic_00001292 | Write a Python function `process_pipeline_v1292` that evaluates `state_flag` against boundary `16` using relational operator `>`, returning mutated state. | def process_pipeline_v1292(state_flag, state_flag):
state_result = 0
if state_flag > 16:
state_result = (state_flag + 10) * 5
else:
state_result = state_flag - 10
return state_result | assert process_pipeline_v1292(21, 10) == 155
assert process_pipeline_v1292(11, 20) == 10 |
py_logic_00001293 | Write a Python function `process_pipeline_v1293` that evaluates `state_flag` against boundary `29` using relational operator `>`, returning mutated state. | def process_pipeline_v1293(state_flag, state_flag):
state_result = 0
if state_flag > 29:
state_result = (state_flag + 4) * 5
else:
state_result = state_flag - 4
return state_result | assert process_pipeline_v1293(34, 10) == 190
assert process_pipeline_v1293(24, 20) == 16 |
py_logic_00001294 | Write a Python function `process_pipeline_v1294` that evaluates `state_flag` against boundary `40` using relational operator `>`, returning mutated state. | def process_pipeline_v1294(state_flag, state_flag):
state_result = 0
if state_flag > 40:
state_result = (state_flag + 4) * 5
else:
state_result = state_flag - 4
return state_result | assert process_pipeline_v1294(45, 10) == 245
assert process_pipeline_v1294(35, 20) == 16 |
py_logic_00001295 | Write a Python function `process_pipeline_v1295` that evaluates `state_flag` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v1295(state_flag, state_flag):
state_result = 0
if state_flag > 50:
state_result = (state_flag + 10) * 5
else:
state_result = state_flag - 10
return state_result | assert process_pipeline_v1295(55, 10) == 325
assert process_pipeline_v1295(45, 20) == 10 |
py_logic_00001296 | Write a Python function `process_pipeline_v1296` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v1296(state_flag, value_b):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 15) * 5
else:
state_result = value_b - 15
return state_result | assert process_pipeline_v1296(61, 10) == 380
assert process_pipeline_v1296(51, 20) == 5 |
py_logic_00001297 | Write a Python function `process_pipeline_v1297` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1297(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 20) * 4
else:
state_result = value_a - 20
return state_result | assert process_pipeline_v1297(64, 10) == 336
assert process_pipeline_v1297(54, 20) == 0 |
py_logic_00001298 | Write a Python function `process_pipeline_v1298` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v1298(value_b, value_a):
state_result = 0
if value_b > 59:
state_result = (value_b + 23) * 4
else:
state_result = value_a - 23
return state_result | assert process_pipeline_v1298(64, 10) == 348
assert process_pipeline_v1298(54, 20) == -3 |
py_logic_00001299 | Write a Python function `process_pipeline_v1299` that evaluates `value_b` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v1299(value_b, value_b):
state_result = 0
if value_b > 55:
state_result = (value_b + 25) * 4
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v1299(60, 10) == 340
assert process_pipeline_v1299(50, 20) == -5 |
py_logic_00001300 | Write a Python function `process_pipeline_v1300` that evaluates `value_b` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v1300(value_b, value_b):
state_result = 0
if value_b > 47:
state_result = (value_b + 25) * 3
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v1300(52, 10) == 231
assert process_pipeline_v1300(42, 20) == -5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.