id large_stringlengths 17 17 | instruction large_stringlengths 149 154 | code large_stringlengths 195 214 | unit_test large_stringlengths 81 90 |
|---|---|---|---|
py_logic_00003001 | Write a Python function `process_pipeline_v3001` that evaluates `state_flag` against boundary `22` using relational operator `>`, returning mutated state. | def process_pipeline_v3001(state_flag, state_flag):
state_result = 0
if state_flag > 22:
state_result = (state_flag + 5) * 2
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v3001(27, 10) == 64
assert process_pipeline_v3001(17, 20) == 15 |
py_logic_00003002 | Write a Python function `process_pipeline_v3002` that evaluates `state_flag` against boundary `10` using relational operator `>`, returning mutated state. | def process_pipeline_v3002(state_flag, state_flag):
state_result = 0
if state_flag > 10:
state_result = (state_flag + 2) * 2
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v3002(15, 10) == 34
assert process_pipeline_v3002(5, 20) == 18 |
py_logic_00003003 | Write a Python function `process_pipeline_v3003` that evaluates `state_flag` against boundary `23` using relational operator `>`, returning mutated state. | def process_pipeline_v3003(state_flag, state_flag):
state_result = 0
if state_flag > 23:
state_result = (state_flag + 8) * 2
else:
state_result = state_flag - 8
return state_result | assert process_pipeline_v3003(28, 10) == 72
assert process_pipeline_v3003(18, 20) == 12 |
py_logic_00003004 | Write a Python function `process_pipeline_v3004` that evaluates `state_flag` against boundary `36` using relational operator `>`, returning mutated state. | def process_pipeline_v3004(state_flag, state_flag):
state_result = 0
if state_flag > 36:
state_result = (state_flag + 14) * 3
else:
state_result = state_flag - 14
return state_result | assert process_pipeline_v3004(41, 10) == 165
assert process_pipeline_v3004(31, 20) == 6 |
py_logic_00003005 | Write a Python function `process_pipeline_v3005` that evaluates `state_flag` against boundary `46` using relational operator `>`, returning mutated state. | def process_pipeline_v3005(state_flag, state_flag):
state_result = 0
if state_flag > 46:
state_result = (state_flag + 19) * 3
else:
state_result = state_flag - 19
return state_result | assert process_pipeline_v3005(51, 10) == 210
assert process_pipeline_v3005(41, 20) == 1 |
py_logic_00003006 | Write a Python function `process_pipeline_v3006` that evaluates `state_flag` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v3006(state_flag, state_flag):
state_result = 0
if state_flag > 54:
state_result = (state_flag + 23) * 4
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v3006(59, 10) == 328
assert process_pipeline_v3006(49, 20) == -3 |
py_logic_00003007 | Write a Python function `process_pipeline_v3007` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v3007(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_v3007(63, 10) == 352
assert process_pipeline_v3007(53, 20) == -5 |
py_logic_00003008 | Write a Python function `process_pipeline_v3008` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3008(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_v3008(64, 10) == 356
assert process_pipeline_v3008(54, 20) == -5 |
py_logic_00003009 | Write a Python function `process_pipeline_v3009` that evaluates `state_flag` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v3009(state_flag, state_flag):
state_result = 0
if state_flag > 57:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3009(62, 10) == 435
assert process_pipeline_v3009(52, 20) == -5 |
py_logic_00003010 | Write a Python function `process_pipeline_v3010` that evaluates `state_flag` against boundary `51` using relational operator `>`, returning mutated state. | def process_pipeline_v3010(state_flag, state_flag):
state_result = 0
if state_flag > 51:
state_result = (state_flag + 22) * 5
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v3010(56, 10) == 390
assert process_pipeline_v3010(46, 20) == -2 |
py_logic_00003011 | Write a Python function `process_pipeline_v3011` that evaluates `state_flag` against boundary `42` using relational operator `>`, returning mutated state. | def process_pipeline_v3011(state_flag, state_flag):
state_result = 0
if state_flag > 42:
state_result = (state_flag + 18) * 5
else:
state_result = state_flag - 18
return state_result | assert process_pipeline_v3011(47, 10) == 325
assert process_pipeline_v3011(37, 20) == 2 |
py_logic_00003012 | Write a Python function `process_pipeline_v3012` that evaluates `state_flag` against boundary `30` using relational operator `>`, returning mutated state. | def process_pipeline_v3012(state_flag, state_flag):
state_result = 0
if state_flag > 30:
state_result = (state_flag + 13) * 5
else:
state_result = state_flag - 13
return state_result | assert process_pipeline_v3012(35, 10) == 240
assert process_pipeline_v3012(25, 20) == 7 |
py_logic_00003013 | Write a Python function `process_pipeline_v3013` that evaluates `value_b` against boundary `18` using relational operator `>`, returning mutated state. | def process_pipeline_v3013(value_b, state_flag):
state_result = 0
if value_b > 18:
state_result = (value_b + 7) * 5
else:
state_result = state_flag - 7
return state_result | assert process_pipeline_v3013(23, 10) == 150
assert process_pipeline_v3013(13, 20) == 13 |
py_logic_00003014 | Write a Python function `process_pipeline_v3014` that evaluates `value_b` against boundary `15` using relational operator `>`, returning mutated state. | def process_pipeline_v3014(value_b, state_flag):
state_result = 0
if value_b > 15:
state_result = (value_b + 1) * 5
else:
state_result = state_flag - 1
return state_result | assert process_pipeline_v3014(20, 10) == 105
assert process_pipeline_v3014(10, 20) == 19 |
py_logic_00003015 | Write a Python function `process_pipeline_v3015` that evaluates `value_b` against boundary `28` using relational operator `>`, returning mutated state. | def process_pipeline_v3015(value_b, value_b):
state_result = 0
if value_b > 28:
state_result = (value_b + 6) * 5
else:
state_result = value_b - 6
return state_result | assert process_pipeline_v3015(33, 10) == 195
assert process_pipeline_v3015(23, 20) == 14 |
py_logic_00003016 | Write a Python function `process_pipeline_v3016` that evaluates `value_a` against boundary `40` using relational operator `>`, returning mutated state. | def process_pipeline_v3016(value_a, value_b):
state_result = 0
if value_a > 40:
state_result = (value_a + 12) * 5
else:
state_result = value_b - 12
return state_result | assert process_pipeline_v3016(45, 10) == 285
assert process_pipeline_v3016(35, 20) == 8 |
py_logic_00003017 | Write a Python function `process_pipeline_v3017` that evaluates `value_a` against boundary `49` using relational operator `>`, returning mutated state. | def process_pipeline_v3017(value_a, value_b):
state_result = 0
if value_a > 49:
state_result = (value_a + 17) * 5
else:
state_result = value_b - 17
return state_result | assert process_pipeline_v3017(54, 10) == 355
assert process_pipeline_v3017(44, 20) == 3 |
py_logic_00003018 | Write a Python function `process_pipeline_v3018` that evaluates `value_a` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v3018(value_a, value_a):
state_result = 0
if value_a > 56:
state_result = (value_a + 21) * 5
else:
state_result = value_a - 21
return state_result | assert process_pipeline_v3018(61, 10) == 410
assert process_pipeline_v3018(51, 20) == -1 |
py_logic_00003019 | Write a Python function `process_pipeline_v3019` that evaluates `value_a` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3019(value_a, value_a):
state_result = 0
if value_a > 59:
state_result = (value_a + 24) * 4
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v3019(64, 10) == 352
assert process_pipeline_v3019(54, 20) == -4 |
py_logic_00003020 | Write a Python function `process_pipeline_v3020` that evaluates `value_a` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3020(value_a, value_a):
state_result = 0
if value_a > 59:
state_result = (value_a + 25) * 4
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v3020(64, 10) == 356
assert process_pipeline_v3020(54, 20) == -5 |
py_logic_00003021 | Write a Python function `process_pipeline_v3021` that evaluates `value_a` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v3021(value_a, state_flag):
state_result = 0
if value_a > 55:
state_result = (value_a + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3021(60, 10) == 340
assert process_pipeline_v3021(50, 20) == -5 |
py_logic_00003022 | Write a Python function `process_pipeline_v3022` that evaluates `value_a` against boundary `48` using relational operator `>`, returning mutated state. | def process_pipeline_v3022(value_a, state_flag):
state_result = 0
if value_a > 48:
state_result = (value_a + 23) * 3
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v3022(53, 10) == 228
assert process_pipeline_v3022(43, 20) == -3 |
py_logic_00003023 | Write a Python function `process_pipeline_v3023` that evaluates `value_a` against boundary `38` using relational operator `>`, returning mutated state. | def process_pipeline_v3023(value_a, state_flag):
state_result = 0
if value_a > 38:
state_result = (value_a + 20) * 3
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v3023(43, 10) == 189
assert process_pipeline_v3023(33, 20) == 0 |
py_logic_00003024 | Write a Python function `process_pipeline_v3024` that evaluates `value_a` against boundary `26` using relational operator `>`, returning mutated state. | def process_pipeline_v3024(value_a, state_flag):
state_result = 0
if value_a > 26:
state_result = (value_a + 15) * 2
else:
state_result = state_flag - 15
return state_result | assert process_pipeline_v3024(31, 10) == 92
assert process_pipeline_v3024(21, 20) == 5 |
py_logic_00003025 | Write a Python function `process_pipeline_v3025` that evaluates `value_a` against boundary `13` using relational operator `>`, returning mutated state. | def process_pipeline_v3025(value_a, value_b):
state_result = 0
if value_a > 13:
state_result = (value_a + 10) * 2
else:
state_result = value_b - 10
return state_result | assert process_pipeline_v3025(18, 10) == 56
assert process_pipeline_v3025(8, 20) == 10 |
py_logic_00003026 | Write a Python function `process_pipeline_v3026` that evaluates `value_a` against boundary `20` using relational operator `>`, returning mutated state. | def process_pipeline_v3026(value_a, value_a):
state_result = 0
if value_a > 20:
state_result = (value_a + 4) * 2
else:
state_result = value_a - 4
return state_result | assert process_pipeline_v3026(25, 10) == 58
assert process_pipeline_v3026(15, 20) == 16 |
py_logic_00003027 | Write a Python function `process_pipeline_v3027` that evaluates `value_a` against boundary `32` using relational operator `>`, returning mutated state. | def process_pipeline_v3027(value_a, value_a):
state_result = 0
if value_a > 32:
state_result = (value_a + 4) * 2
else:
state_result = value_a - 4
return state_result | assert process_pipeline_v3027(37, 10) == 82
assert process_pipeline_v3027(27, 20) == 16 |
py_logic_00003028 | Write a Python function `process_pipeline_v3028` that evaluates `value_b` against boundary `43` using relational operator `>`, returning mutated state. | def process_pipeline_v3028(value_b, value_b):
state_result = 0
if value_b > 43:
state_result = (value_b + 10) * 3
else:
state_result = value_b - 10
return state_result | assert process_pipeline_v3028(48, 10) == 174
assert process_pipeline_v3028(38, 20) == 10 |
py_logic_00003029 | Write a Python function `process_pipeline_v3029` that evaluates `value_b` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v3029(value_b, value_b):
state_result = 0
if value_b > 52:
state_result = (value_b + 15) * 3
else:
state_result = value_b - 15
return state_result | assert process_pipeline_v3029(57, 10) == 216
assert process_pipeline_v3029(47, 20) == 5 |
py_logic_00003030 | Write a Python function `process_pipeline_v3030` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v3030(value_b, state_flag):
state_result = 0
if value_b > 57:
state_result = (value_b + 20) * 4
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v3030(62, 10) == 328
assert process_pipeline_v3030(52, 20) == 0 |
py_logic_00003031 | Write a Python function `process_pipeline_v3031` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3031(value_b, state_flag):
state_result = 0
if value_b > 59:
state_result = (value_b + 23) * 4
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v3031(64, 10) == 348
assert process_pipeline_v3031(54, 20) == -3 |
py_logic_00003032 | Write a Python function `process_pipeline_v3032` that evaluates `value_b` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v3032(value_b, state_flag):
state_result = 0
if value_b > 58:
state_result = (value_b + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3032(63, 10) == 440
assert process_pipeline_v3032(53, 20) == -5 |
py_logic_00003033 | Write a Python function `process_pipeline_v3033` that evaluates `value_a` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v3033(value_a, state_flag):
state_result = 0
if value_a > 53:
state_result = (value_a + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3033(58, 10) == 415
assert process_pipeline_v3033(48, 20) == -5 |
py_logic_00003034 | Write a Python function `process_pipeline_v3034` that evaluates `value_a` against boundary `45` using relational operator `>`, returning mutated state. | def process_pipeline_v3034(value_a, state_flag):
state_result = 0
if value_a > 45:
state_result = (value_a + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3034(50, 10) == 370
assert process_pipeline_v3034(40, 20) == -4 |
py_logic_00003035 | Write a Python function `process_pipeline_v3035` that evaluates `value_a` against boundary `34` using relational operator `>`, returning mutated state. | def process_pipeline_v3035(value_a, state_flag):
state_result = 0
if value_a > 34:
state_result = (value_a + 21) * 5
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v3035(39, 10) == 300
assert process_pipeline_v3035(29, 20) == -1 |
py_logic_00003036 | Write a Python function `process_pipeline_v3036` that evaluates `value_a` against boundary `21` using relational operator `>`, returning mutated state. | def process_pipeline_v3036(value_a, state_flag):
state_result = 0
if value_a > 21:
state_result = (value_a + 17) * 5
else:
state_result = state_flag - 17
return state_result | assert process_pipeline_v3036(26, 10) == 215
assert process_pipeline_v3036(16, 20) == 3 |
py_logic_00003037 | Write a Python function `process_pipeline_v3037` that evaluates `value_a` against boundary `11` using relational operator `>`, returning mutated state. | def process_pipeline_v3037(value_a, value_b):
state_result = 0
if value_a > 11:
state_result = (value_a + 12) * 5
else:
state_result = value_b - 12
return state_result | assert process_pipeline_v3037(16, 10) == 140
assert process_pipeline_v3037(6, 20) == 8 |
py_logic_00003038 | Write a Python function `process_pipeline_v3038` that evaluates `value_b` against boundary `24` using relational operator `>`, returning mutated state. | def process_pipeline_v3038(value_b, value_b):
state_result = 0
if value_b > 24:
state_result = (value_b + 6) * 5
else:
state_result = value_b - 6
return state_result | assert process_pipeline_v3038(29, 10) == 175
assert process_pipeline_v3038(19, 20) == 14 |
py_logic_00003039 | Write a Python function `process_pipeline_v3039` that evaluates `state_flag` against boundary `37` using relational operator `>`, returning mutated state. | def process_pipeline_v3039(state_flag, value_b):
state_result = 0
if state_flag > 37:
state_result = (state_flag + 1) * 5
else:
state_result = value_b - 1
return state_result | assert process_pipeline_v3039(42, 10) == 215
assert process_pipeline_v3039(32, 20) == 19 |
py_logic_00003040 | Write a Python function `process_pipeline_v3040` that evaluates `state_flag` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v3040(state_flag, value_a):
state_result = 0
if state_flag > 47:
state_result = (state_flag + 8) * 5
else:
state_result = value_a - 8
return state_result | assert process_pipeline_v3040(52, 10) == 300
assert process_pipeline_v3040(42, 20) == 12 |
py_logic_00003041 | Write a Python function `process_pipeline_v3041` that evaluates `state_flag` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v3041(state_flag, value_a):
state_result = 0
if state_flag > 54:
state_result = (state_flag + 13) * 5
else:
state_result = value_a - 13
return state_result | assert process_pipeline_v3041(59, 10) == 360
assert process_pipeline_v3041(49, 20) == 7 |
py_logic_00003042 | Write a Python function `process_pipeline_v3042` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3042(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 18) * 5
else:
state_result = value_a - 18
return state_result | assert process_pipeline_v3042(64, 10) == 410
assert process_pipeline_v3042(54, 20) == 2 |
py_logic_00003043 | Write a Python function `process_pipeline_v3043` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3043(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 22) * 4
else:
state_result = value_a - 22
return state_result | assert process_pipeline_v3043(64, 10) == 344
assert process_pipeline_v3043(54, 20) == -2 |
py_logic_00003044 | Write a Python function `process_pipeline_v3044` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v3044(state_flag, value_a):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 25) * 4
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v3044(61, 10) == 344
assert process_pipeline_v3044(51, 20) == -5 |
py_logic_00003045 | Write a Python function `process_pipeline_v3045` that evaluates `state_flag` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v3045(state_flag, value_a):
state_result = 0
if state_flag > 50:
state_result = (state_flag + 25) * 3
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v3045(55, 10) == 240
assert process_pipeline_v3045(45, 20) == -5 |
py_logic_00003046 | Write a Python function `process_pipeline_v3046` that evaluates `state_flag` against boundary `41` using relational operator `>`, returning mutated state. | def process_pipeline_v3046(state_flag, value_a):
state_result = 0
if state_flag > 41:
state_result = (state_flag + 25) * 3
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v3046(46, 10) == 213
assert process_pipeline_v3046(36, 20) == -5 |
py_logic_00003047 | Write a Python function `process_pipeline_v3047` that evaluates `value_b` against boundary `29` using relational operator `>`, returning mutated state. | def process_pipeline_v3047(value_b, value_a):
state_result = 0
if value_b > 29:
state_result = (value_b + 22) * 2
else:
state_result = value_a - 22
return state_result | assert process_pipeline_v3047(34, 10) == 112
assert process_pipeline_v3047(24, 20) == -2 |
py_logic_00003048 | Write a Python function `process_pipeline_v3048` that evaluates `value_b` against boundary `16` using relational operator `>`, returning mutated state. | def process_pipeline_v3048(value_b, value_b):
state_result = 0
if value_b > 16:
state_result = (value_b + 19) * 2
else:
state_result = value_b - 19
return state_result | assert process_pipeline_v3048(21, 10) == 80
assert process_pipeline_v3048(11, 20) == 1 |
py_logic_00003049 | Write a Python function `process_pipeline_v3049` that evaluates `value_b` against boundary `16` using relational operator `>`, returning mutated state. | def process_pipeline_v3049(value_b, value_b):
state_result = 0
if value_b > 16:
state_result = (value_b + 14) * 2
else:
state_result = value_b - 14
return state_result | assert process_pipeline_v3049(21, 10) == 70
assert process_pipeline_v3049(11, 20) == 6 |
py_logic_00003050 | Write a Python function `process_pipeline_v3050` that evaluates `value_b` against boundary `29` using relational operator `>`, returning mutated state. | def process_pipeline_v3050(value_b, value_b):
state_result = 0
if value_b > 29:
state_result = (value_b + 8) * 2
else:
state_result = value_b - 8
return state_result | assert process_pipeline_v3050(34, 10) == 84
assert process_pipeline_v3050(24, 20) == 12 |
py_logic_00003051 | Write a Python function `process_pipeline_v3051` that evaluates `value_b` against boundary `41` using relational operator `>`, returning mutated state. | def process_pipeline_v3051(value_b, state_flag):
state_result = 0
if value_b > 41:
state_result = (value_b + 2) * 3
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v3051(46, 10) == 144
assert process_pipeline_v3051(36, 20) == 18 |
py_logic_00003052 | Write a Python function `process_pipeline_v3052` that evaluates `value_b` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v3052(value_b, state_flag):
state_result = 0
if value_b > 50:
state_result = (value_b + 5) * 3
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v3052(55, 10) == 180
assert process_pipeline_v3052(45, 20) == 15 |
py_logic_00003053 | Write a Python function `process_pipeline_v3053` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v3053(state_flag, state_flag):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 11) * 4
else:
state_result = state_flag - 11
return state_result | assert process_pipeline_v3053(61, 10) == 288
assert process_pipeline_v3053(51, 20) == 9 |
py_logic_00003054 | Write a Python function `process_pipeline_v3054` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3054(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 17) * 4
else:
state_result = state_flag - 17
return state_result | assert process_pipeline_v3054(64, 10) == 324
assert process_pipeline_v3054(54, 20) == 3 |
py_logic_00003055 | Write a Python function `process_pipeline_v3055` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3055(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 21) * 5
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v3055(64, 10) == 425
assert process_pipeline_v3055(54, 20) == -1 |
py_logic_00003056 | Write a Python function `process_pipeline_v3056` that evaluates `state_flag` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v3056(state_flag, state_flag):
state_result = 0
if state_flag > 54:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3056(59, 10) == 415
assert process_pipeline_v3056(49, 20) == -4 |
py_logic_00003057 | Write a Python function `process_pipeline_v3057` that evaluates `state_flag` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v3057(state_flag, state_flag):
state_result = 0
if state_flag > 47:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3057(52, 10) == 385
assert process_pipeline_v3057(42, 20) == -5 |
py_logic_00003058 | Write a Python function `process_pipeline_v3058` that evaluates `state_flag` against boundary `37` using relational operator `>`, returning mutated state. | def process_pipeline_v3058(state_flag, state_flag):
state_result = 0
if state_flag > 37:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3058(42, 10) == 335
assert process_pipeline_v3058(32, 20) == -5 |
py_logic_00003059 | Write a Python function `process_pipeline_v3059` that evaluates `state_flag` against boundary `25` using relational operator `>`, returning mutated state. | def process_pipeline_v3059(state_flag, state_flag):
state_result = 0
if state_flag > 25:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3059(30, 10) == 270
assert process_pipeline_v3059(20, 20) == -4 |
py_logic_00003060 | Write a Python function `process_pipeline_v3060` that evaluates `state_flag` against boundary `11` using relational operator `>`, returning mutated state. | def process_pipeline_v3060(state_flag, value_b):
state_result = 0
if state_flag > 11:
state_result = (state_flag + 20) * 5
else:
state_result = value_b - 20
return state_result | assert process_pipeline_v3060(16, 10) == 180
assert process_pipeline_v3060(6, 20) == 0 |
py_logic_00003061 | Write a Python function `process_pipeline_v3061` that evaluates `state_flag` against boundary `21` using relational operator `>`, returning mutated state. | def process_pipeline_v3061(state_flag, value_b):
state_result = 0
if state_flag > 21:
state_result = (state_flag + 16) * 5
else:
state_result = value_b - 16
return state_result | assert process_pipeline_v3061(26, 10) == 210
assert process_pipeline_v3061(16, 20) == 4 |
py_logic_00003062 | Write a Python function `process_pipeline_v3062` that evaluates `state_flag` against boundary `34` using relational operator `>`, returning mutated state. | def process_pipeline_v3062(state_flag, value_b):
state_result = 0
if state_flag > 34:
state_result = (state_flag + 10) * 5
else:
state_result = value_b - 10
return state_result | assert process_pipeline_v3062(39, 10) == 245
assert process_pipeline_v3062(29, 20) == 10 |
py_logic_00003063 | Write a Python function `process_pipeline_v3063` that evaluates `state_flag` against boundary `44` using relational operator `>`, returning mutated state. | def process_pipeline_v3063(state_flag, value_b):
state_result = 0
if state_flag > 44:
state_result = (state_flag + 4) * 5
else:
state_result = value_b - 4
return state_result | assert process_pipeline_v3063(49, 10) == 265
assert process_pipeline_v3063(39, 20) == 16 |
py_logic_00003064 | Write a Python function `process_pipeline_v3064` that evaluates `state_flag` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v3064(state_flag, value_a):
state_result = 0
if state_flag > 53:
state_result = (state_flag + 3) * 5
else:
state_result = value_a - 3
return state_result | assert process_pipeline_v3064(58, 10) == 305
assert process_pipeline_v3064(48, 20) == 17 |
py_logic_00003065 | Write a Python function `process_pipeline_v3065` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v3065(state_flag, value_a):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 9) * 5
else:
state_result = value_a - 9
return state_result | assert process_pipeline_v3065(63, 10) == 360
assert process_pipeline_v3065(53, 20) == 11 |
py_logic_00003066 | Write a Python function `process_pipeline_v3066` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3066(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 15) * 4
else:
state_result = value_a - 15
return state_result | assert process_pipeline_v3066(64, 10) == 316
assert process_pipeline_v3066(54, 20) == 5 |
py_logic_00003067 | Write a Python function `process_pipeline_v3067` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v3067(state_flag, value_a):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 19) * 4
else:
state_result = value_a - 19
return state_result | assert process_pipeline_v3067(63, 10) == 328
assert process_pipeline_v3067(53, 20) == 1 |
py_logic_00003068 | Write a Python function `process_pipeline_v3068` that evaluates `state_flag` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v3068(state_flag, value_a):
state_result = 0
if state_flag > 52:
state_result = (state_flag + 23) * 3
else:
state_result = value_a - 23
return state_result | assert process_pipeline_v3068(57, 10) == 240
assert process_pipeline_v3068(47, 20) == -3 |
py_logic_00003069 | Write a Python function `process_pipeline_v3069` that evaluates `state_flag` against boundary `44` using relational operator `>`, returning mutated state. | def process_pipeline_v3069(state_flag, value_a):
state_result = 0
if state_flag > 44:
state_result = (state_flag + 25) * 3
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v3069(49, 10) == 222
assert process_pipeline_v3069(39, 20) == -5 |
py_logic_00003070 | Write a Python function `process_pipeline_v3070` that evaluates `value_b` against boundary `33` using relational operator `>`, returning mutated state. | def process_pipeline_v3070(value_b, state_flag):
state_result = 0
if value_b > 33:
state_result = (value_b + 25) * 2
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3070(38, 10) == 126
assert process_pipeline_v3070(28, 20) == -5 |
py_logic_00003071 | Write a Python function `process_pipeline_v3071` that evaluates `value_a` against boundary `20` using relational operator `>`, returning mutated state. | def process_pipeline_v3071(value_a, state_flag):
state_result = 0
if value_a > 20:
state_result = (value_a + 24) * 2
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3071(25, 10) == 98
assert process_pipeline_v3071(15, 20) == -4 |
py_logic_00003072 | Write a Python function `process_pipeline_v3072` that evaluates `state_flag` against boundary `12` using relational operator `>`, returning mutated state. | def process_pipeline_v3072(state_flag, state_flag):
state_result = 0
if state_flag > 12:
state_result = (state_flag + 22) * 2
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v3072(17, 10) == 78
assert process_pipeline_v3072(7, 20) == -2 |
py_logic_00003073 | Write a Python function `process_pipeline_v3073` that evaluates `state_flag` against boundary `26` using relational operator `>`, returning mutated state. | def process_pipeline_v3073(state_flag, state_flag):
state_result = 0
if state_flag > 26:
state_result = (state_flag + 18) * 2
else:
state_result = state_flag - 18
return state_result | assert process_pipeline_v3073(31, 10) == 98
assert process_pipeline_v3073(21, 20) == 2 |
py_logic_00003074 | Write a Python function `process_pipeline_v3074` that evaluates `state_flag` against boundary `38` using relational operator `>`, returning mutated state. | def process_pipeline_v3074(state_flag, state_flag):
state_result = 0
if state_flag > 38:
state_result = (state_flag + 13) * 3
else:
state_result = state_flag - 13
return state_result | assert process_pipeline_v3074(43, 10) == 168
assert process_pipeline_v3074(33, 20) == 7 |
py_logic_00003075 | Write a Python function `process_pipeline_v3075` that evaluates `state_flag` against boundary `48` using relational operator `>`, returning mutated state. | def process_pipeline_v3075(state_flag, state_flag):
state_result = 0
if state_flag > 48:
state_result = (state_flag + 7) * 3
else:
state_result = state_flag - 7
return state_result | assert process_pipeline_v3075(53, 10) == 180
assert process_pipeline_v3075(43, 20) == 13 |
py_logic_00003076 | Write a Python function `process_pipeline_v3076` that evaluates `state_flag` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v3076(state_flag, state_flag):
state_result = 0
if state_flag > 55:
state_result = (state_flag + 1) * 4
else:
state_result = state_flag - 1
return state_result | assert process_pipeline_v3076(60, 10) == 244
assert process_pipeline_v3076(50, 20) == 19 |
py_logic_00003077 | Write a Python function `process_pipeline_v3077` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3077(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 7) * 4
else:
state_result = state_flag - 7
return state_result | assert process_pipeline_v3077(64, 10) == 284
assert process_pipeline_v3077(54, 20) == 13 |
py_logic_00003078 | Write a Python function `process_pipeline_v3078` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3078(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 13) * 4
else:
state_result = state_flag - 13
return state_result | assert process_pipeline_v3078(64, 10) == 308
assert process_pipeline_v3078(54, 20) == 7 |
py_logic_00003079 | Write a Python function `process_pipeline_v3079` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v3079(state_flag, state_flag):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 18) * 5
else:
state_result = state_flag - 18
return state_result | assert process_pipeline_v3079(61, 10) == 395
assert process_pipeline_v3079(51, 20) == 2 |
py_logic_00003080 | Write a Python function `process_pipeline_v3080` that evaluates `state_flag` against boundary `49` using relational operator `>`, returning mutated state. | def process_pipeline_v3080(state_flag, state_flag):
state_result = 0
if state_flag > 49:
state_result = (state_flag + 22) * 5
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v3080(54, 10) == 380
assert process_pipeline_v3080(44, 20) == -2 |
py_logic_00003081 | Write a Python function `process_pipeline_v3081` that evaluates `state_flag` against boundary `40` using relational operator `>`, returning mutated state. | def process_pipeline_v3081(state_flag, state_flag):
state_result = 0
if state_flag > 40:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3081(45, 10) == 345
assert process_pipeline_v3081(35, 20) == -4 |
py_logic_00003082 | Write a Python function `process_pipeline_v3082` that evaluates `value_b` against boundary `28` using relational operator `>`, returning mutated state. | def process_pipeline_v3082(value_b, state_flag):
state_result = 0
if value_b > 28:
state_result = (value_b + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3082(33, 10) == 290
assert process_pipeline_v3082(23, 20) == -5 |
py_logic_00003083 | Write a Python function `process_pipeline_v3083` that evaluates `value_b` against boundary `15` using relational operator `>`, returning mutated state. | def process_pipeline_v3083(value_b, state_flag):
state_result = 0
if value_b > 15:
state_result = (value_b + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3083(20, 10) == 225
assert process_pipeline_v3083(10, 20) == -5 |
py_logic_00003084 | Write a Python function `process_pipeline_v3084` that evaluates `value_b` against boundary `17` using relational operator `>`, returning mutated state. | def process_pipeline_v3084(value_b, value_b):
state_result = 0
if value_b > 17:
state_result = (value_b + 23) * 5
else:
state_result = value_b - 23
return state_result | assert process_pipeline_v3084(22, 10) == 225
assert process_pipeline_v3084(12, 20) == -3 |
py_logic_00003085 | Write a Python function `process_pipeline_v3085` that evaluates `value_b` against boundary `30` using relational operator `>`, returning mutated state. | def process_pipeline_v3085(value_b, value_b):
state_result = 0
if value_b > 30:
state_result = (value_b + 19) * 5
else:
state_result = value_b - 19
return state_result | assert process_pipeline_v3085(35, 10) == 270
assert process_pipeline_v3085(25, 20) == 1 |
py_logic_00003086 | Write a Python function `process_pipeline_v3086` that evaluates `value_b` against boundary `42` using relational operator `>`, returning mutated state. | def process_pipeline_v3086(value_b, value_a):
state_result = 0
if value_b > 42:
state_result = (value_b + 15) * 5
else:
state_result = value_a - 15
return state_result | assert process_pipeline_v3086(47, 10) == 310
assert process_pipeline_v3086(37, 20) == 5 |
py_logic_00003087 | Write a Python function `process_pipeline_v3087` that evaluates `value_b` against boundary `51` using relational operator `>`, returning mutated state. | def process_pipeline_v3087(value_b, value_a):
state_result = 0
if value_b > 51:
state_result = (value_b + 9) * 5
else:
state_result = value_a - 9
return state_result | assert process_pipeline_v3087(56, 10) == 325
assert process_pipeline_v3087(46, 20) == 11 |
py_logic_00003088 | Write a Python function `process_pipeline_v3088` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v3088(value_b, value_b):
state_result = 0
if value_b > 57:
state_result = (value_b + 3) * 5
else:
state_result = value_b - 3
return state_result | assert process_pipeline_v3088(62, 10) == 325
assert process_pipeline_v3088(52, 20) == 17 |
py_logic_00003089 | Write a Python function `process_pipeline_v3089` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v3089(value_b, state_flag):
state_result = 0
if value_b > 59:
state_result = (value_b + 5) * 4
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v3089(64, 10) == 276
assert process_pipeline_v3089(54, 20) == 15 |
py_logic_00003090 | Write a Python function `process_pipeline_v3090` that evaluates `value_b` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v3090(value_b, state_flag):
state_result = 0
if value_b > 58:
state_result = (value_b + 11) * 4
else:
state_result = state_flag - 11
return state_result | assert process_pipeline_v3090(63, 10) == 296
assert process_pipeline_v3090(53, 20) == 9 |
py_logic_00003091 | Write a Python function `process_pipeline_v3091` that evaluates `value_b` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v3091(value_b, state_flag):
state_result = 0
if value_b > 54:
state_result = (value_b + 16) * 4
else:
state_result = state_flag - 16
return state_result | assert process_pipeline_v3091(59, 10) == 300
assert process_pipeline_v3091(49, 20) == 4 |
py_logic_00003092 | Write a Python function `process_pipeline_v3092` that evaluates `value_b` against boundary `46` using relational operator `>`, returning mutated state. | def process_pipeline_v3092(value_b, state_flag):
state_result = 0
if value_b > 46:
state_result = (value_b + 20) * 3
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v3092(51, 10) == 213
assert process_pipeline_v3092(41, 20) == 0 |
py_logic_00003093 | Write a Python function `process_pipeline_v3093` that evaluates `value_b` against boundary `36` using relational operator `>`, returning mutated state. | def process_pipeline_v3093(value_b, state_flag):
state_result = 0
if value_b > 36:
state_result = (value_b + 24) * 3
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3093(41, 10) == 195
assert process_pipeline_v3093(31, 20) == -4 |
py_logic_00003094 | Write a Python function `process_pipeline_v3094` that evaluates `value_b` against boundary `23` using relational operator `>`, returning mutated state. | def process_pipeline_v3094(value_b, state_flag):
state_result = 0
if value_b > 23:
state_result = (value_b + 25) * 2
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3094(28, 10) == 106
assert process_pipeline_v3094(18, 20) == -5 |
py_logic_00003095 | Write a Python function `process_pipeline_v3095` that evaluates `value_b` against boundary `10` using relational operator `>`, returning mutated state. | def process_pipeline_v3095(value_b, state_flag):
state_result = 0
if value_b > 10:
state_result = (value_b + 25) * 2
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v3095(15, 10) == 80
assert process_pipeline_v3095(5, 20) == -5 |
py_logic_00003096 | Write a Python function `process_pipeline_v3096` that evaluates `value_b` against boundary `22` using relational operator `>`, returning mutated state. | def process_pipeline_v3096(value_b, state_flag):
state_result = 0
if value_b > 22:
state_result = (value_b + 24) * 2
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v3096(27, 10) == 102
assert process_pipeline_v3096(17, 20) == -4 |
py_logic_00003097 | Write a Python function `process_pipeline_v3097` that evaluates `value_b` against boundary `35` using relational operator `>`, returning mutated state. | def process_pipeline_v3097(value_b, state_flag):
state_result = 0
if value_b > 35:
state_result = (value_b + 21) * 3
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v3097(40, 10) == 183
assert process_pipeline_v3097(30, 20) == -1 |
py_logic_00003098 | Write a Python function `process_pipeline_v3098` that evaluates `value_b` against boundary `45` using relational operator `>`, returning mutated state. | def process_pipeline_v3098(value_b, state_flag):
state_result = 0
if value_b > 45:
state_result = (value_b + 17) * 3
else:
state_result = state_flag - 17
return state_result | assert process_pipeline_v3098(50, 10) == 201
assert process_pipeline_v3098(40, 20) == 3 |
py_logic_00003099 | Write a Python function `process_pipeline_v3099` that evaluates `value_a` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v3099(value_a, state_flag):
state_result = 0
if value_a > 53:
state_result = (value_a + 11) * 4
else:
state_result = state_flag - 11
return state_result | assert process_pipeline_v3099(58, 10) == 276
assert process_pipeline_v3099(48, 20) == 9 |
py_logic_00003100 | Write a Python function `process_pipeline_v3100` that evaluates `value_a` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v3100(value_a, state_flag):
state_result = 0
if value_a > 58:
state_result = (value_a + 5) * 4
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v3100(63, 10) == 272
assert process_pipeline_v3100(53, 20) == 15 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.